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++ - Crash inspiegabile
Forum - C/C++ - Crash inspiegabile

Avatar
nuanda79 (Normal User)
Newbie


Messaggi: 3
Iscritto: 10/12/2009

Segnala al moderatore
Postato alle 8:43
Giovedì, 10/12/2009
Salve a tutti,
sono nuovo del forum, ho scoperto questo sito pochi giorni fa mentre stavo cercando qualche info sul c++ e devo dire che mi ha aiutato abbastanza.
Sto sviluppando un piccolo software in c++ con l'ausilio delle SDL.
La programmazione è proceduta bene fino a ieri, quando mi son reso conto che il programma crashava nel momento in cui nel codice aggiungevo una nuova variabile, di qualsiasi tipo...bastava la dichiarazione.
Nel senso
1- il programma si compila senza errori o warning e funziona al lancio.
2- aggiungo anche solo la dichiarazione di una nuova variabile di qualsiasi tipo e il programma continua a compilarsi senza problemi ma al lancio crasha....

Avete una vaga idea di quale possa essere il motivo?

Vi rigranzio anche solo di aver letto :)
(in realtà son disperato perchè così nn posso far niente, nn posso andare avanti!) :(


Non rompiamo, si inchini alla scienza.
PM Quote
Avatar
ingMark (Ex-Member)
Pro


Messaggi: 176
Iscritto: 19/07/2009

Segnala al moderatore
Postato alle 9:31
Giovedì, 10/12/2009
se non posti il codice è impossibile aiutarti :k:


Mamma diceva sempre che stupido è chi lo stupido fa.
PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 11:29
Giovedì, 10/12/2009

probabilmente il problema non è li dove si presenta, il fatto che aggiungendo una dichiarazione compila ma crasha tutto è sicuramente dovuto alla corruzione dello stack in seguito a qualche uso sbagliato di puntatori e simili. Posta il codice e cerchiamo il problema.


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


Messaggi: 3
Iscritto: 10/12/2009

Segnala al moderatore
Postato alle 11:58
Giovedì, 10/12/2009
Vi ringrazio delle risposte.
Postare il codice è un bel problema, visto che è un malloppo di roba!
In pratica ho una diecina di classi e un sacco di righe di codice...
...visto che negli ultimi tempi ho lavorato solo sulla classe Level, potrei postare quella, probabilmente il problema è lì, anche perchè il fulcro del programma è lì.
Ah, sicuramente troverete degli "orrori" di programmazione...abbiate pietà ;)


levels.h

Codice sorgente - presumibilmente C++

  1. #ifndef __CLASS_LEVELS__
  2. #define __CLASS_LEVELS__
  3.  
  4. #include <SDL.h>
  5. #include <vector>
  6. #include <string>
  7. #include <iostream>
  8. #include <fstream>
  9. #include <stdlib.h>
  10. #include <time.h>
  11. #include "background.h"
  12. #include "input.h"
  13. #include "sprite.h"
  14. #include "font.h"
  15.  
  16. #define FOTO_MARGIN_X        40         //x della foto
  17. #define FOTO_MARGIN_Y       113         //y della foto
  18. #define MIRROR_DIFF_X       486         //x del mirror (copia della foto)(la y è la stessa di foto)
  19. #define ERRORE_MARGIN_X     480         //x dell'errore
  20. #define ERRORE_MARGIN_Y     620         //y dell'errore
  21. #define ERRORE_SPACE_X       60         //distanza tra un errore e l'altro
  22. #define LIVELLO_FONT_X      170         //x del font LIVELLO
  23. #define LIVELLO_FONT_Y      200         //y del font LIVELLO
  24. #define COMPLETED_FONT_X    150         //x del font COMPLETED
  25. #define COMPLETED_FONT_Y    200         //y del font COMPLETED
  26. #define ERRORE_CENTER_X      25         //per ottenere il centro dell'errore (* per la coordinata x)
  27. #define ERRORE_CENTER_Y      25         //per ottenere il centro dell'errore (* per la coordinata y)
  28. #define TEMPO_X              40         //x della barra del tempo
  29. #define TEMPO_Y             530         //y della barra del tempo
  30. #define FPS                  50         //frames al secondo
  31. #define BASE_TIME            60         //tempo di base al livello 1, 60 secondi
  32. #define LEVEL_DIFF_TIME       5         //differenza di tempo fra i livelli  
  33. #define MALUS                50         //penalità di tempo nel caso di click errato
  34.  
  35. using namespace std;
  36.  
  37. class Levels
  38. {
  39. protected:
  40.         //Creo istanza dello sfondo
  41.         Background background;
  42.         Input input_game;
  43.     Font livello;
  44.     Font completed;
  45.     Font gameover;
  46.     Sprite foto;
  47.     Sprite mirror;
  48.     Sprite errore;
  49.     Sprite ok;
  50.     Sprite tempo;
  51.  
  52. private:
  53.         //numero di livello
  54.         int l_stage;
  55.         int shot;
  56.     int a;
  57.     int estr;
  58.     int pos_x;
  59.     int pos_y;
  60.     bool load;
  61.     int level;
  62.     char st_level[4];
  63.     char st_livello[7];
  64.     int ciclo;
  65.     long cut;
  66.     int score;
  67.  
  68.         //ultimo tempo di aggiornamento del frame
  69.         long update_time;
  70.         //vector<string> shoot_files;
  71. public:
  72.         //Costruttore
  73.         Levels();
  74.  
  75.         //funzione che carica i settagi del livello
  76.         void set_level();
  77.  
  78.         //Si esegue il livello
  79.         int exec();
  80.  
  81.     int casual(int num);
  82.  
  83.     int get_mouse_pos(int xy);
  84.  
  85.     bool collision(int width, int height, int x, int y);
  86.     bool collision_2(int err_pos_x, int err_pos_y);
  87.  
  88.     void wait(int seconds);
  89.    
  90.     //variabili per memorizzare i dati del file di testo
  91.     string linea;
  92.     vector<string> nome_foto;
  93.     vector<string> nome_mirror;
  94.     vector<string> errore_files;
  95.     vector<string> ok_files;
  96.     vector<string> tempo_files;
  97.     vector<int> err_x;
  98.     vector<int> err_y;
  99.     vector<int> disegna_errori;
  100.  
  101.         //Distruttore
  102.         ~Levels();
  103. };
  104.  
  105. #endif




levels.cpp


Codice sorgente - presumibilmente C++

  1. #include "levels.h"
  2.  
  3. #define DIM_H 1024
  4. #define DIM_V 768
  5.  
  6. Levels::Levels()
  7. {
  8.     level = 0;
  9. }
  10.  
  11. //funzione che setta lo stage e chiama background per il caricamento dello sfondo
  12. void Levels::set_level()
  13. {
  14.     //svuoto i vettori nel caso contenessero oggetti della partita precedente
  15.     nome_foto.clear();
  16.     nome_mirror.clear();
  17.     err_x.clear();
  18.     err_y.clear();    
  19.  
  20.     ifstream read("data/data.txt",ios::in);  // apre il file 'data.txt' in lettura
  21.     //fstream read_write("data.txt",ios::in | ios::out);
  22. /*
  23.     if(!read) {
  24.         cout << "Il file non esiste!";
  25.         return -1;
  26.     }
  27. */
  28.     //ofstream write("data/rubrica.txt",ios::out);  //apre il file 'rubrica' in scrittura
  29.  
  30.     //funzione che legge riga per riga il mio file data.txt
  31.     //la struttura del file txt deve essere del tipo: stringa int int;int int;int int;int int;int int;
  32.     while(!read.eof()) //mentre non siamo arrivati alla fine del file
  33.     {      
  34.         getline(read ,linea,' ');       //leggo dal file la prima parola e la memorizzo in "linea"
  35.         linea.resize(remove(linea.begin(), linea.end(), '\n') - linea.begin() ); //rimuovo il carattere di ritorno a capo all'inizio della stringa
  36.         nome_foto.push_back("data/original/" + linea);      //la memorizzo nel vettore "nome_foto"
  37.         nome_mirror.push_back("data/copy/" + linea);    //la memorizzo nel vettore "nome_mirror"
  38.         for(int i=0;i<=4;i++)
  39.         {
  40.             getline(read ,linea,' ');
  41.             err_x.push_back(atoi(linea.c_str())-ERRORE_CENTER_X); //con la funzione atoi trasformo una stringa in int
  42.             getline(read ,linea,';');
  43.             err_y.push_back(atoi(linea.c_str())-ERRORE_CENTER_Y);
  44.         }
  45.     }    
  46.  
  47.     nome_foto.pop_back(); //tolgo l'ultimo elemento al vettore nome_img in quanto è il carattere terminatore EOF
  48.     nome_mirror.pop_back(); //lo stesso faccio col vettore nome_mirror
  49.  
  50.     //chiudo il file di testo
  51.     read.close();
  52. /*
  53.     for(int r = 0;r<=err_x.size()-1;r++)
  54.     write << err_x[r] << err_y[r] << '\n' ;
  55.  
  56.     write.close();
  57. */
  58.  
  59.     //carico e imposto lo sfondo dei livelli
  60.         background.load_bg(1);
  61.  
  62.     //memorizzo l'indirizzo dell'immagine errore e ok nel vettore errore_files e ok_files
  63.     errore_files.push_back("data/errore.png");
  64.     ok_files.push_back("data/ok.png");
  65.  
  66.     //setto errore e ok
  67.     errore.set_sprite(errore_files, 0, 0, 0);
  68.     ok.set_sprite(ok_files, 0, 0, 0);    
  69.  
  70.     //disegno l'immagine
  71.     //foto.set_sprite(nome_foto, 38, 37, 0);
  72.  
  73.     //disegno l'immagine specchio
  74.     //mirror.set_sprite(nome_mirror, 527, 37, 0);
  75.    
  76.     //imposto immagine e coordinate per lo sprite tempo
  77.     tempo_files.push_back("data/time.png");
  78.     tempo.set_sprite(tempo_files, TEMPO_X, TEMPO_Y, 0);
  79.  
  80.     //imposto a 0 tutti e 5 gli elementi del vettore disegna_errori per la partenza della partita
  81.     for(int i=0;i<=4;i++) disegna_errori.push_back(0);
  82.    
  83.     //setto il livello iniziale e imposto la variabile load = 0 per caricare il necessario alla partenza del gioco
  84.     //imposto ciclo a 0 e il taglio del tempo a 0
  85.     level = 1;
  86.     load = 0;
  87.     cut = 0;
  88.     ciclo = 0;
  89.     score = 0;
  90. }
  91.  
  92. int Levels::exec()
  93. {
  94.     //disegno lo sfondo
  95.         background.draw_bgmenu();
  96.    
  97.     //se è scaduto il tempo..
  98.     if(tempo.get_w() <= cut)
  99.     {
  100.             //mi occupo di disegnare la scritta "gameover"
  101.             gameover.load_font(0xFF,0xFF,0xFF,COMPLETED_FONT_X,COMPLETED_FONT_Y,"Game Over");
  102.             gameover.draw_menu_font();
  103.             gameover.load_font(0xFF,0xFF,0xFF,COMPLETED_FONT_X + MIRROR_DIFF_X,COMPLETED_FONT_Y,"Game Over");
  104.             gameover.draw_menu_font();
  105.            
  106.             //aggiorno lo schermo
  107.             SDL_Flip(screen);
  108.  
  109.             //attendo 2 sec a meno che nn ci sia pressione del mouse
  110.             wait(2);
  111.  
  112.             //ridisegno lo sfondo per sovrascrivere la scritta Game Over
  113.                 background.draw_bgmenu();
  114.  
  115.             //converto lo score da int a string e lo salvo in st_livello
  116.             itoa(score, st_livello, 10);
  117.            
  118.             //carico e disegno le scritte "your score" e il punteggio
  119.             gameover.load_font(0xFF,0xFF,0xFF,COMPLETED_FONT_X,COMPLETED_FONT_Y,"Your score");
  120.             gameover.draw_menu_font();
  121.             completed.load_font(0xFF,0xFF,0xFF,COMPLETED_FONT_X,280, st_livello);
  122.             completed.draw_menu_font();
  123.  
  124.             //aggiorno lo schermo
  125.             SDL_Flip(screen);
  126.  
  127.             //attendo 2 sec a meno che nn ci sia pressione del mouse
  128.             wait(2);
  129.  
  130.             return 2;
  131.     }
  132.  
  133. //----------------------------------------------------------
  134.     if(load == 0)
  135.     {    
  136.         if(level > 1)
  137.         {
  138.             //dal secondo livello in poi, mi occupo di cancellare la foto del livello appena fatto sia da foto che da mirror
  139.             nome_foto.erase(nome_foto.begin()+(estr));
  140.             nome_mirror.erase(nome_mirror.begin()+(estr));
  141.  
  142.             //cancello le coordinate degli errori relative alla foto eliminata
  143.             for(int t=0;t<=4;t++)
  144.             {
  145.                 err_x.erase(err_x.begin()+estr*5);
  146.                 err_y.erase(err_y.begin()+estr*5);
  147.             }
  148.  
  149.             //mi occupo di disegnare la scritta "completed"
  150.             completed.load_font(0xFF,0xFF,0xFF,COMPLETED_FONT_X,COMPLETED_FONT_Y,"Completed");
  151.             completed.draw_menu_font();
  152.             completed.load_font(0xFF,0xFF,0xFF,COMPLETED_FONT_X + MIRROR_DIFF_X,COMPLETED_FONT_Y,"Completed");
  153.             completed.draw_menu_font();
  154.            
  155.  
  156.             //aggiorno lo schermo
  157.             SDL_Flip(screen);
  158.  
  159.             //attendo 2 sec a meno che nn ci sia pressione del mouse
  160.             wait(2);
  161.  
  162.             //disegno lo sfondo di nuovo per sovrascrivere le scritte
  163.             background.draw_bgmenu();
  164.  
  165.            
  166.             //calcolo il punteggio di fine livello
  167.             score = score + (tempo.get_w()-cut);
  168.            
  169.             //converto lo score da int a string e lo salvo in st_livello
  170.             itoa(score, st_livello, 10);
  171.            
  172.             //carico e disegno le scritte "score" e il punteggio
  173.             completed.load_font(0xFF,0xFF,0xFF,COMPLETED_FONT_X,COMPLETED_FONT_Y, "Score");
  174.             completed.draw_menu_font();
  175.             completed.load_font(0xFF,0xFF,0xFF,COMPLETED_FONT_X,280, st_livello);
  176.             completed.draw_menu_font();
  177.  
  178.             //aggiorno lo schermo
  179.             SDL_Flip(screen);
  180.  
  181.             //attendo 2 sec a meno che nn ci sia pressione del mouse
  182.             wait(2);
  183.  
  184.             //SDL_Delay(1000);
  185.  
  186.             //disegno lo sfondo di nuovo per sovrascrivere le scritte
  187.             background.draw_bgmenu();
  188.  
  189.             //se non ci sono più foto per i livelli, si ritorna al menu(provvisorio)
  190.             if(nome_foto.size() == 0)
  191.             {
  192.                 return 2;
  193.             }
  194.         }
  195.        
  196.         //copio la scritta Livello nella variabile st_livello
  197.         strcpy(st_livello, "Livello ");
  198.  
  199.         //trasformo da int a string la variabile level e la salvo in st_level
  200.         itoa(level, st_level, 10);
  201.  
  202.         //carico le impostazioni per la scritta "livello" concatenando la stringa st_livello con la st_level
  203.             livello.load_font(0xFF,0xFF,0xFF,LIVELLO_FONT_X,LIVELLO_FONT_Y,strcat(st_livello, st_level));
  204.        
  205.         //disegno la scritta livello
  206.         livello.draw_menu_font();
  207.  
  208.         //carico le impostazioni per la scritta "livello" nel mirror
  209.             livello.load_font(0xFF,0xFF,0xFF,LIVELLO_FONT_X + MIRROR_DIFF_X,LIVELLO_FONT_Y,st_livello);
  210.        
  211.         //disegno la scritta livello nel mirror
  212.         livello.draw_menu_font();
  213.  
  214.         //aggiorno lo schermo
  215.         SDL_Flip(screen);        
  216.  
  217.         //SDL_Delay(2000);
  218.  
  219.         //attendo 2 sec a meno che nn ci sia pressione del mouse
  220.         wait(2);
  221.  
  222.         //estraggo un numero casuale da 0 alla dimensione del vettore nome_foto e lo salvo in estr
  223.         estr = casual(nome_foto.size());  
  224.  
  225.         //scelgo la foto col numero casuale
  226.         //foto.set_sprite_frame(estr);
  227.  
  228.         //setto la foto relativa al numero casuale per l'originale
  229.         foto.set_sprite(nome_foto, FOTO_MARGIN_X, FOTO_MARGIN_Y, estr);
  230.  
  231.         //scelgo la foto specchio relativa
  232.         //mirror.set_sprite_frame(estr);
  233.  
  234.         //setto la foto relativa al numero casuale per il mirror
  235.         mirror.set_sprite(nome_mirror, FOTO_MARGIN_X + MIRROR_DIFF_X, FOTO_MARGIN_Y, estr);        
  236.  
  237.         //riporto a 0 tutti e 5 gli elementi del vettore disegna_errori alla partenza del nuovo livello
  238.         for(int i=0;i<=4;i++) disegna_errori[i] = 0;
  239.  
  240.         //pongo load = 1 per non ripetere queste operazioni sopra fino a quando nn siano stati trovati i 5 errori nel gioco
  241.         load = 1;    
  242.  
  243.         //imposto il ciclo e il taglio al tempo a zero
  244.         ciclo = 0;
  245.         cut = 0;
  246.     }
  247. //----------------------------------------------------------
  248.  
  249.     //disegno la foto originale
  250.     foto.draw_sprite();
  251.  
  252.     //disegno la foto del mirror
  253.     mirror.draw_sprite();
  254.  
  255.     //segno ogni iterazione del livello
  256.     ciclo = ciclo+1;
  257.  
  258.     //se le iterazioni sono maggiori di FPS = 50 (cioè un secondo)...
  259.     if(ciclo > FPS)
  260.     {
  261.         //...si controlla se siamo prima del livello 9, in ta caso
  262.         if(level <= 9)
  263.         {
  264.             //si diminuisce il tempo in base a questa formula e si riporta il ciclo a 0
  265.             cut = cut + (tempo.get_w()/ (BASE_TIME - ((level*LEVEL_DIFF_TIME)-LEVEL_DIFF_TIME)) ); //15 per ottenere 60 sec.
  266.             ciclo = 0;
  267.         }
  268.         else
  269.         {
  270.             //altra formula per diminuire il tempo se siamo a livello sopra il 9
  271.             cut = cut + (tempo.get_w()/ (BASE_TIME - 40)); //cut = cut + ((tempo.get_w()/BASE_TIME)-40);
  272.             ciclo = 0;
  273.         }
  274.     }  
  275.  
  276.     //disegno la barra del tempo
  277.     tempo.draw_sprite_time(cut);
  278.  
  279.  
  280.     //a seconda di quale dei 5 errori siano stati trovati disegno il relativo cerchietto nella giusta posizione e il relativo ok
  281.     if(disegna_errori[0] == 1)
  282.     {
  283.         errore.set_sprite_pos(err_x[estr*5] + FOTO_MARGIN_X, err_y[estr*5] + FOTO_MARGIN_Y);
  284.         errore.draw_sprite();
  285.         errore.set_sprite_pos(err_x[estr*5] + FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5] + FOTO_MARGIN_Y);
  286.         errore.draw_sprite();
  287.         ok.set_sprite_pos(ERRORE_MARGIN_X, ERRORE_MARGIN_Y);
  288.         ok.draw_sprite();
  289.     }
  290.     else
  291.     {
  292.         errore.set_sprite_pos(ERRORE_MARGIN_X, ERRORE_MARGIN_Y);
  293.         errore.draw_sprite();
  294.     }
  295.     if(disegna_errori[1] == 1)
  296.     {
  297.         errore.set_sprite_pos(err_x[estr*5+1]+ FOTO_MARGIN_X, err_y[estr*5+1] + FOTO_MARGIN_Y);
  298.         errore.draw_sprite();
  299.         errore.set_sprite_pos(err_x[estr*5+1]+ FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+1] + FOTO_MARGIN_Y);
  300.         errore.draw_sprite();
  301.         ok.set_sprite_pos(ERRORE_MARGIN_X + ERRORE_SPACE_X, ERRORE_MARGIN_Y);
  302.         ok.draw_sprite();
  303.     }
  304.     else
  305.     {
  306.         errore.set_sprite_pos(ERRORE_MARGIN_X + ERRORE_SPACE_X, ERRORE_MARGIN_Y);
  307.         errore.draw_sprite();
  308.     }
  309.     if(disegna_errori[2] == 1)
  310.     {
  311.         errore.set_sprite_pos(err_x[estr*5+2]+ FOTO_MARGIN_X, err_y[estr*5+2] + FOTO_MARGIN_Y);
  312.         errore.draw_sprite();
  313.         errore.set_sprite_pos(err_x[estr*5+2]+ FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+2] + FOTO_MARGIN_Y);
  314.         errore.draw_sprite();
  315.         ok.set_sprite_pos(ERRORE_MARGIN_X + ERRORE_SPACE_X*2, ERRORE_MARGIN_Y);
  316.         ok.draw_sprite();
  317.     }
  318.     else
  319.     {
  320.         errore.set_sprite_pos(ERRORE_MARGIN_X + ERRORE_SPACE_X*2, ERRORE_MARGIN_Y);
  321.         errore.draw_sprite();
  322.     }
  323.     if(disegna_errori[3] == 1)
  324.     {
  325.         errore.set_sprite_pos(err_x[estr*5+3]+ FOTO_MARGIN_X, err_y[estr*5+3] + FOTO_MARGIN_Y);
  326.         errore.draw_sprite();
  327.         errore.set_sprite_pos(err_x[estr*5+3]+ FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+3] + FOTO_MARGIN_Y);
  328.         errore.draw_sprite();
  329.         ok.set_sprite_pos(ERRORE_MARGIN_X + ERRORE_SPACE_X*3, ERRORE_MARGIN_Y);
  330.         ok.draw_sprite();
  331.     }
  332.     else
  333.     {
  334.         errore.set_sprite_pos(ERRORE_MARGIN_X + ERRORE_SPACE_X*3, ERRORE_MARGIN_Y);
  335.         errore.draw_sprite();
  336.     }
  337.     if(disegna_errori[4] == 1)
  338.     {
  339.         errore.set_sprite_pos(err_x[estr*5+4]+ FOTO_MARGIN_X, err_y[estr*5+4] + FOTO_MARGIN_Y);
  340.         errore.draw_sprite();
  341.         errore.set_sprite_pos(err_x[estr*5+4]+ FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+4] + FOTO_MARGIN_Y);
  342.         errore.draw_sprite();
  343.         ok.set_sprite_pos(ERRORE_MARGIN_X + ERRORE_SPACE_X*4, ERRORE_MARGIN_Y);
  344.         ok.draw_sprite();
  345.     }
  346.     else
  347.     {
  348.         errore.set_sprite_pos(ERRORE_MARGIN_X + ERRORE_SPACE_X*4, ERRORE_MARGIN_Y);
  349.         errore.draw_sprite();
  350.     }
  351.    
  352.     //se sono stati trovati tutti e 5 gli errori si passa al livello successivo e si pone load = 0 per scegliere una nuova foto
  353.     if(disegna_errori[0] == 1 && disegna_errori[1] == 1 && disegna_errori[2] == 1 && disegna_errori[3] == 1 && disegna_errori[4] == 1)
  354.     {
  355.         level = level + 1;
  356.         load = 0;
  357.     }
  358.  
  359.         //Controllo l'eventuale pressione di un tasto con una chiamata alla funzione exec di input
  360.         switch(input_game.exec())
  361.         {
  362.                 case 0: //cioè è stato premuto ESC
  363.                 {
  364.                         return 2; //cioè GAME_MENU
  365.                 }break;
  366.                 case 1: //cioè è stato premuto il pulsante SX del mouse
  367.                 {
  368.             //si controlla se il click è avvenuto a una delle coordinate dell'errore ed eventualmente si segnala quale
  369.             for(int s=0;s<=4;s++)
  370.             {
  371.                 if(collision_2(err_x[estr*5+s]+FOTO_MARGIN_X, err_y[estr*5+s] + FOTO_MARGIN_Y) || collision_2(err_x[estr*5+s]+FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+s] + FOTO_MARGIN_Y)) disegna_errori[s] = 1;
  372.             }
  373.             //nel caso in cui il click del mouse non corrisponda alle coordinate di un errore...
  374.             if((collision_2(err_x[estr*5+0]+FOTO_MARGIN_X, err_y[estr*5+0] + FOTO_MARGIN_Y)) || (collision_2(err_x[estr*5+0]+FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+0] + FOTO_MARGIN_Y))
  375.                || (collision_2(err_x[estr*5+1]+FOTO_MARGIN_X, err_y[estr*5+1] + FOTO_MARGIN_Y)) || (collision_2(err_x[estr*5+1]+FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+1] + FOTO_MARGIN_Y))
  376.                || (collision_2(err_x[estr*5+2]+FOTO_MARGIN_X, err_y[estr*5+2] + FOTO_MARGIN_Y)) || (collision_2(err_x[estr*5+2]+FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+2] + FOTO_MARGIN_Y))
  377.                || (collision_2(err_x[estr*5+3]+FOTO_MARGIN_X, err_y[estr*5+3] + FOTO_MARGIN_Y)) || (collision_2(err_x[estr*5+3]+FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+3] + FOTO_MARGIN_Y))
  378.                || (collision_2(err_x[estr*5+4]+FOTO_MARGIN_X, err_y[estr*5+4] + FOTO_MARGIN_Y)) || (collision_2(err_x[estr*5+4]+FOTO_MARGIN_X + MIRROR_DIFF_X, err_y[estr*5+4] + FOTO_MARGIN_Y)))
  379.             {
  380.                  ;
  381.             }
  382.             //...si fa questo
  383.             else
  384.             {  
  385.                 //nel caso di click sbagliato sottraggo un po' di tempo a disposizione MALUS
  386.                 cut = cut + MALUS;
  387.             }
  388.                         return 4; //cioè GAME_RUN
  389.                 }break;
  390.                 default: //cioè nessun tasto è stato premuto
  391.         {
  392.             return 4;
  393.         }break;
  394.         }//end switch
  395. }
  396.  
  397. //funzione per estrarre un numero casuale
  398. int Levels::casual(int num)
  399. {
  400.     srand((unsigned)time(NULL));
  401.     a = rand() % num;
  402.     return a;
  403. }
  404.  
  405.  
  406. bool Levels::collision(int width, int height, int x, int y)
  407. {
  408.     if(get_mouse_pos(0) > x && get_mouse_pos(0) < x + width && get_mouse_pos(1) > y && get_mouse_pos(0) < y + height) return 1;
  409.     else return 0;
  410. }
  411.  
  412. bool Levels::collision_2(int err_pos_x, int err_pos_y)
  413. {
  414.     if(get_mouse_pos(0) > err_pos_x && get_mouse_pos(0) < err_pos_x + 50 && get_mouse_pos(1) > err_pos_y && get_mouse_pos(1) < err_pos_y + 50) return 1;
  415.     else return 0;
  416. }
  417.  
  418. //funzione che restituisce le coordinate del mouse
  419. //ritorna l'ascissa o l'ordinata del mouse
  420. //se l'argomento passato è 0 ritorna l'ascissa, se è 1 ritorna l'ordinata
  421. int Levels::get_mouse_pos(int xy)
  422. {
  423.     SDL_GetMouseState(&pos_x, &pos_y);
  424.     if(xy == 0) return pos_x;
  425.     if(xy == 1) return pos_y;
  426. }
  427.  
  428. //funzione di attesa
  429. void Levels::wait(int seconds)
  430. {
  431.   clock_t endwait;
  432.   endwait = clock () + seconds * CLOCKS_PER_SEC ;
  433.   while (clock() < endwait)
  434.     {
  435.         if(input_game.exec()==1) break;
  436.     }
  437. }
  438.  
  439. Levels::~Levels()
  440. {
  441.         ;
  442. }



Non rompiamo, si inchini alla scienza.
PM Quote
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6108
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 16:12
Giovedì, 10/12/2009
Zippa il progetto e allegalo (con i sorgenti), cosi' e' possibile eseguirlo e provare capire dov'e' il problema.


Seguimi su Twitter: http://www.twitter.com/pierotofy

Fai quello che ti piace, e fallo bene.
PM Quote
Avatar
nuanda79 (Normal User)
Newbie


Messaggi: 3
Iscritto: 10/12/2009

Segnala al moderatore
Postato alle 16:28
Giovedì, 10/12/2009
Vi ringrazio moltissimo della disponibilità, forse ho trovato il guaio...ma non è in levels,
è in un'altra classe, ho provato a fare un po' di prove commentando parti di codice che potevano creare problemi e penso di essere arrivato alla soluzione!

Adesso faccio qualche altro test, se poi non dovessi risolvere vi allego tutto il progetto.
:k:


Non rompiamo, si inchini alla scienza.
PM Quote