Michael Balourdas / Mbed 2 deprecated TriviaGame_Final

Dependencies:   4DGL-uLCD-SE SDFileSystem mbed wave_player

Fork of TriviaGame by Michael Balourdas

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 #include "SDFileSystem.h"
00003 #include "uLCD_4DGL.h"
00004 #include "wave_player.h"
00005 #include "mpr121.h"
00006 #include <vector>
00007 #include <string>
00008 #include "stdlib.h"
00009 #include "stdio.h"
00010 
00011 
00012 
00013 AnalogOut DACout(p18); // used to play sound on speaker
00014 //wave player plays a *.wav file to D/A and a PWM
00015 wave_player waver(&DACout);
00016 InterruptIn interrupt(p26);
00017 I2C i2c(p9, p10);
00018 Mpr121 mpr121(&i2c, Mpr121::ADD_VSS);
00019 Serial pc(USBTX, USBRX);
00020 
00021 uLCD_4DGL uLCD(p28,p27,p29); // serial tx, serial rx, reset pin;
00022 SDFileSystem sd(p5, p6, p7, p8, "sd"); //SD card setup
00023 int Score;
00024 int HighScore = 0;
00025 int question = 0;
00026 bool answer = 1;
00027 int index = 0;
00028 bool check = 0;
00029 int value = 0;
00030 std::vector<int> v;
00031 Timer t;
00032 float tr = 0;
00033 int mode = 0;
00034 int counter = 0;
00035 int cScore = 0;
00036 int tScore = 0;
00037 int nScore = 0;
00038 int tHighScore = 0;
00039 int nHighScore = 0;
00040 int cHighScore = 0;
00041 string game;
00042 char nHigh[2];
00043 char tHigh[2];
00044 char cHigh[2];
00045 
00046  void itoa(int n, char s[])
00047  {
00048      int i, sign;
00049  
00050      if ((sign = n) < 0)  /* record sign */
00051          n = -n;          /* make n positive */
00052      i = 0;
00053      do {       /* generate digits in reverse order */
00054          s[i++] = n % 10 + '0';   /* get next digit */
00055      } while ((n /= 10) > 0);     /* delete it */
00056      
00057  
00058  }
00059 
00060 int main()
00061 {
00062     srand(time(NULL));
00063     while (true){
00064         answer = 1;
00065         for (int i=0; i<16; i++){
00066             v.push_back(i+1);
00067         }
00068         check = 0;
00069         question = 0;
00070         uLCD.baudrate(30);
00071         uLCD.background_color(BLACK);
00072         uLCD.color(BLUE);
00073         uLCD.cls();
00074         if (mode == 1){
00075             uLCD.cls();
00076             uLCD.media_init();
00077             uLCD.set_sector_address(0x0000, 0x009F);
00078             uLCD.display_image(0,0);
00079             wait(2);
00080             uLCD.cls();
00081             uLCD.printf("Final Score:%d\n", nScore);
00082             if (nScore > nHighScore){
00083             nHighScore = nScore;
00084             uLCD.printf("NEW NORMAL\n HIGH SCORE!\n %d", nHighScore);
00085             wait(2);
00086         }
00087         itoa(nHighScore, nHigh);
00088         pc.puts(nHigh);
00089         uLCD.printf("\nClick New Game");
00090         }
00091         if (mode == 2){
00092             uLCD.cls();
00093             uLCD.media_init();
00094             uLCD.set_sector_address(0x0000, 0x009F);
00095             uLCD.display_image(0,0);
00096             wait(2);
00097             uLCD.cls();
00098             uLCD.printf("Final Score:%d\n", tScore);
00099             if (tScore > tHighScore){
00100             tHighScore = tScore;
00101             uLCD.printf("NEW TIMED\n HIGH SCORE!\n %d", tHighScore);
00102             wait(2);
00103         }
00104         itoa(tHighScore, tHigh);
00105         pc.puts(tHigh);
00106         uLCD.printf("\nClick New Game");
00107             }
00108         if (mode == 4){
00109             uLCD.cls();
00110             uLCD.media_init();
00111             uLCD.set_sector_address(0x0000, 0x009F);
00112             uLCD.display_image(0,0);
00113             wait(2);
00114             uLCD.cls();
00115             uLCD.printf("Final Score: %d\n", cScore);
00116             if (cScore > cHighScore){
00117             cHighScore = cScore;
00118             uLCD.printf("NEW CHALLENGE\n HIGH SCORE!\n %d", cHighScore);
00119             wait(2);
00120         }
00121         itoa(cHighScore, cHigh);
00122         pc.puts(cHigh);
00123         uLCD.printf("\nClick New Game");
00124         }
00125         wait(2);
00126         uLCD.cls();
00127         nScore = 0;
00128         tScore=0;
00129         cScore=0;
00130         counter = 0;
00131 
00132         uLCD.cls();
00133         uLCD.printf("Choose a Game Mode"); 
00134         //uLCD.printf("High Score: %d \n", HighScore);
00135         //uLCD.printf("\n0) Normal Game\n High Score:%d\n1) Timed Game\n High Score:%d\n2)Challenge Game\n High Score:%d", nHighScore, tHighScore, cHighScore);
00136         while (1){
00137             game = pc.getc();
00138             //mode=mpr121.read(0x00);
00139 //            mode +=mpr121.read(0x01)<<8; 
00140             if (game == "1"){
00141                 mode = 1;
00142                 break;
00143                 }
00144             if (game == "2"){
00145                 mode = 2;
00146                 break;
00147             }
00148              if (game == "4"){
00149                  mode = 4;
00150                  break;
00151                  }
00152             }
00153 
00154         uLCD.cls();
00155         t.reset();
00156         t.stop();
00157         t.start();
00158         //end of main menu
00159         if (v.size() !=0){
00160         while (answer == 1){
00161             if (mode == 2){
00162                 tr = t.read();
00163                 if (tr > 60){
00164                     break;
00165                     }
00166                     }
00167             if (mode == 1){
00168                 if (counter > 6){
00169                     break;
00170                     }
00171                 }
00172             if (v.size() == 0){
00173                 break;
00174                 }
00175             index = rand() %v.size();
00176             question = v.at(index);
00177             v.erase(v.begin()+index);
00178             check = 0;
00179             uLCD.cls();
00180             if (mode == 4){
00181                 uLCD.printf("Score: %d", cScore);
00182             }
00183             
00184             wait(1);
00185             if (question == 1){
00186                 value = 0;
00187                 uLCD.cls();
00188                 uLCD.locate(1,2);
00189                 uLCD.printf("Who won the World Series in 2016?\n\n\n");
00190                 uLCD.printf("1) Cleveland\nIndians\n");
00191                 uLCD.printf("2) Chicago Cubs\n");
00192                 uLCD.printf("3) San Diego\nPadres\n");
00193                 while (check == 0){
00194                     int value=mpr121.read(0x00);
00195                     value +=mpr121.read(0x01)<<8;
00196                     if (value == 2){
00197                         //play game over
00198                         uLCD.cls();
00199                         uLCD.media_init();
00200                         uLCD.set_sector_address(0x0000, 0x005E);
00201                         uLCD.display_image(0,0);
00202                         FILE *wave_file;   
00203                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00204                         waver.play(wave_file);
00205                         fclose(wave_file);
00206                         wait(1);
00207                         uLCD.cls();
00208                         if (mode == 4){
00209                         answer = 0;
00210                         }
00211                         counter = counter +1;
00212                         
00213                         check = 1;
00214                         }
00215                     if (value == 4){
00216                         //play correct image
00217                         uLCD.cls();
00218                         uLCD.media_init();
00219                         uLCD.set_sector_address(0x0000, 0x001D);
00220                         uLCD.display_image(0,0);
00221                         FILE *wave_file;   
00222                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00223                         waver.play(wave_file);
00224                         fclose(wave_file);
00225                         wait(1);
00226                         uLCD.cls();
00227                         if (mode == 1){
00228                         nScore = nScore+1;
00229                         }
00230                         if (mode == 2){
00231                         tScore = tScore+1;
00232                         }
00233                         if (mode == 4){
00234                         cScore = cScore+1;
00235                         }
00236                         wait(1);
00237                         if (mode == 1){
00238                         answer = 1;
00239                         }
00240                         counter=counter+1;
00241                         check = 1;
00242                         }
00243                     if (value == 8){
00244                         //play game over
00245                         uLCD.cls();
00246                         uLCD.media_init();
00247                         uLCD.set_sector_address(0x0000, 0x005E);
00248                         uLCD.display_image(0,0);
00249                         FILE *wave_file;   
00250                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00251                         waver.play(wave_file);
00252                         fclose(wave_file);
00253                         wait(1);
00254                         uLCD.cls();
00255                         if (mode == 4){
00256                         answer = 0;
00257                         }
00258                         counter = counter+1;
00259                         check = 1;
00260                     }
00261                 }
00262             }
00263             if (question == 2){
00264                 value = 0;
00265                 uLCD.cls();
00266                 uLCD.locate(1,2);
00267                 uLCD.printf("What is the\n capital of South\n Dakota?\n\n");
00268                 uLCD.printf("1) Pierre\n");
00269                 uLCD.printf("2) Bismarck\n");
00270                 uLCD.printf("3) Lakota\n");
00271                 while (check == 0){
00272                     int value=mpr121.read(0x00);
00273                     value +=mpr121.read(0x01)<<8;
00274                     if (value == 2){
00275                         //play game over
00276                         uLCD.cls();
00277                         uLCD.media_init();
00278                         uLCD.set_sector_address(0x0000, 0x005E);
00279                         uLCD.display_image(0,0);
00280                         FILE *wave_file;   
00281                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00282                         waver.play(wave_file);
00283                         fclose(wave_file);
00284                         wait(1);
00285                         uLCD.cls();
00286                         if (mode == 4){
00287                         answer = 0;
00288                         }
00289                         counter = counter +1;
00290                         
00291                         check = 1;
00292                         }
00293                     if (value == 4){
00294                         //play correct image
00295                         uLCD.cls();
00296                         uLCD.media_init();
00297                         uLCD.set_sector_address(0x0000, 0x001D);
00298                         uLCD.display_image(0,0);
00299                         FILE *wave_file;   
00300                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00301                         waver.play(wave_file);
00302                         fclose(wave_file);
00303                         wait(1);
00304                         uLCD.cls();
00305                         if (mode == 1){
00306                         nScore = nScore+1;
00307                         }
00308                         if (mode == 2){
00309                         tScore = tScore+1;
00310                         }
00311                         if (mode == 4){
00312                         cScore = cScore+1;
00313                         }
00314                         //uLCD.printf("Score: %d", Score);
00315                         wait(1);
00316                         if (mode == 1){
00317                         answer = 1;
00318                         }
00319                             counter=counter+1;
00320                         check = 1;
00321                         }
00322                     if (value == 8){
00323                         //play game over
00324                         uLCD.cls();
00325                         uLCD.media_init();
00326                         uLCD.set_sector_address(0x0000, 0x005E);
00327                         uLCD.display_image(0,0);
00328                         FILE *wave_file;   
00329                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00330                         waver.play(wave_file);
00331                         fclose(wave_file);
00332                         wait(1);
00333                         uLCD.cls();
00334                         if (mode == 4){
00335                         answer = 0;
00336                         }
00337                         counter = counter+1;
00338                         check = 1;
00339                     }
00340                 }
00341             }
00342   if (question == 3){
00343                 value = 0;
00344                 uLCD.cls();
00345                 uLCD.locate(1,2);
00346                 uLCD.printf("Who wrote The \nGrapes of Wrath?\n\n\n");
00347                 uLCD.printf("1)Ernest Hemingway");
00348                 uLCD.printf("2)George Orwell\n");
00349                 uLCD.printf("3)John Steinbeck\n");
00350                 while (check == 0){
00351                     int value=mpr121.read(0x00);
00352                     value +=mpr121.read(0x01)<<8;
00353                     if (value == 2){
00354                         //play game over
00355                         uLCD.cls();
00356                         uLCD.media_init();
00357                         uLCD.set_sector_address(0x0000, 0x005E);
00358                         uLCD.display_image(0,0);
00359                         FILE *wave_file;   
00360                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00361                         waver.play(wave_file);
00362                         fclose(wave_file);
00363                         wait(1);
00364                         uLCD.cls();
00365                         if (mode == 4){
00366                         answer = 0;
00367                         }
00368                         counter = counter +1;
00369                         
00370                         check = 1;
00371                         }
00372                     if (value == 8){
00373                         //play correct image
00374                         uLCD.cls();
00375                         uLCD.media_init();
00376                         uLCD.set_sector_address(0x0000, 0x001D);
00377                         uLCD.display_image(0,0);
00378                         FILE *wave_file;   
00379                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00380                         waver.play(wave_file);
00381                         fclose(wave_file);
00382                         wait(1);
00383                         uLCD.cls();
00384                         if (mode == 1){
00385                         nScore = nScore+1;
00386                         }
00387                         if (mode == 2){
00388                         tScore = tScore+1;
00389                         }
00390                         if (mode == 4){
00391                         cScore = cScore+1;
00392                         }
00393                         //uLCD.printf("Score: %d", Score);
00394                         wait(1);
00395                         if (mode == 1){
00396                         answer = 1;
00397                         }
00398                             counter=counter+1;
00399                         check = 1;
00400                         }
00401                     if (value == 4){
00402                         //play game over
00403                         uLCD.cls();
00404                         uLCD.media_init();
00405                         uLCD.set_sector_address(0x0000, 0x005E);
00406                         uLCD.display_image(0,0);
00407                         FILE *wave_file;   
00408                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00409                         waver.play(wave_file);
00410                         fclose(wave_file);
00411                         wait(1);
00412                         uLCD.cls();
00413                         if (mode == 4){
00414                         answer = 0;
00415                         }
00416                         counter = counter+1;
00417                         check = 1;
00418                     }
00419                 }
00420             }
00421             if (question == 4){
00422                 value = 0;
00423                 uLCD.cls();
00424                 uLCD.locate(1,2);
00425                 uLCD.printf("What year was \nEinstein born?\n\n\n");
00426                 uLCD.printf("1) 1900\n");
00427                 uLCD.printf("2) 1879\n");
00428                 uLCD.printf("3) 1873\n");
00429                 while (check == 0){
00430                     int value=mpr121.read(0x00);
00431                     value +=mpr121.read(0x01)<<8;
00432                     if (value == 2){
00433                         //play game over
00434                         uLCD.cls();
00435                         uLCD.media_init();
00436                         uLCD.set_sector_address(0x0000, 0x005E);
00437                         uLCD.display_image(0,0);
00438                         FILE *wave_file;   
00439                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00440                         waver.play(wave_file);
00441                         fclose(wave_file);
00442                         wait(1);
00443                         uLCD.cls();
00444                         if (mode == 4){
00445                         answer = 0;
00446                         }
00447                         counter = counter +1;
00448                         
00449                         check = 1;
00450                         }
00451                     if (value == 4){
00452                         //play correct image
00453                         uLCD.cls();
00454                         uLCD.media_init();
00455                         uLCD.set_sector_address(0x0000, 0x001D);
00456                         uLCD.display_image(0,0);
00457                         FILE *wave_file;   
00458                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00459                         waver.play(wave_file);
00460                         fclose(wave_file);
00461                         wait(1);
00462                         uLCD.cls();
00463                         if (mode == 1){
00464                         nScore = nScore+1;
00465                         }
00466                         if (mode == 2){
00467                         tScore = tScore+1;
00468                         }
00469                         if (mode == 4){
00470                         cScore = cScore+1;
00471                         }
00472                         //uLCD.printf("Score: %d", Score);
00473                         wait(1);
00474                         if (mode == 1){
00475                         answer = 1;
00476                         }
00477                             counter=counter+1;
00478                         check = 1;
00479                         }
00480                     if (value == 8){
00481                         //play game over
00482                         uLCD.cls();
00483                         uLCD.media_init();
00484                         uLCD.set_sector_address(0x0000, 0x005E);
00485                         uLCD.display_image(0,0);
00486                         FILE *wave_file;   
00487                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00488                         waver.play(wave_file);
00489                         fclose(wave_file);
00490                         wait(1);
00491                         uLCD.cls();
00492                         if (mode == 4){
00493                         answer = 0;
00494                         }
00495                         counter = counter+1;
00496                         check = 1;
00497                     }
00498                 }
00499             }
00500             if (question == 5){
00501                 value = 0;
00502                 uLCD.cls();
00503                 uLCD.locate(1,2);
00504                 uLCD.printf("Which song is by the Rolling Stones?\n\n\n");
00505                 uLCD.printf("1) Paint It Black\n");
00506                 uLCD.printf("2) Feel For \nThe Devil\n");
00507                 uLCD.printf("3) Let It Be\n");
00508                 while (check == 0){
00509                     int value=mpr121.read(0x00);
00510                     value +=mpr121.read(0x01)<<8;
00511                     if (value == 4){
00512                         //play game over
00513                         uLCD.cls();
00514                         uLCD.media_init();
00515                         uLCD.set_sector_address(0x0000, 0x005E);
00516                         uLCD.display_image(0,0);
00517                         FILE *wave_file;   
00518                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00519                         waver.play(wave_file);
00520                         fclose(wave_file);
00521                         wait(1);
00522                         uLCD.cls();
00523                         if (mode == 4){
00524                         answer = 0;
00525                         }
00526                         counter = counter +1;
00527                         
00528                         check = 1;
00529                         }
00530                     if (value == 2){
00531                         //play correct image
00532                         uLCD.cls();
00533                         uLCD.media_init();
00534                         uLCD.set_sector_address(0x0000, 0x001D);
00535                         uLCD.display_image(0,0);
00536                         FILE *wave_file;   
00537                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00538                         waver.play(wave_file);
00539                         fclose(wave_file);
00540                         wait(1);
00541                         uLCD.cls();
00542                         if (mode == 1){
00543                         nScore = nScore+1;
00544                         }
00545                         if (mode == 2){
00546                         tScore = tScore+1;
00547                         }
00548                         if (mode == 4){
00549                         cScore = cScore+1;
00550                         }
00551                         //uLCD.printf("Score: %d", Score);
00552                         wait(1);
00553                         if (mode == 1){
00554                         answer = 1;
00555                         }
00556                             counter=counter+1;
00557                         check = 1;
00558                         }
00559                     if (value == 8){
00560                         //play game over
00561                         uLCD.cls();
00562                         uLCD.media_init();
00563                         uLCD.set_sector_address(0x0000, 0x005E);
00564                         uLCD.display_image(0,0);
00565                         FILE *wave_file;   
00566                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00567                         waver.play(wave_file);
00568                         fclose(wave_file);
00569                         wait(1);
00570                         uLCD.cls();
00571                         if (mode == 4){
00572                         answer = 0;
00573                         }
00574                         counter = counter+1;
00575                         check = 1;
00576                     }
00577                 }
00578             }
00579              if (question == 6){
00580                 value = 0;
00581                 uLCD.cls();
00582                 uLCD.locate(1,2);
00583                 uLCD.printf("Where was Hitler born?\n\n\n");
00584                 uLCD.printf("1) Poland\n");
00585                 uLCD.printf("2) Germany\n");
00586                 uLCD.printf("3) Austria\n");
00587                 while (check == 0){
00588                     int value=mpr121.read(0x00);
00589                     value +=mpr121.read(0x01)<<8;
00590                     if (value == 2){
00591                         //play game over
00592                         uLCD.cls();
00593                         uLCD.media_init();
00594                         uLCD.set_sector_address(0x0000, 0x005E);
00595                         uLCD.display_image(0,0);
00596                         FILE *wave_file;   
00597                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00598                         waver.play(wave_file);
00599                         fclose(wave_file);
00600                         wait(1);
00601                         uLCD.cls();
00602                         if (mode == 4){
00603                         answer = 0;
00604                         }
00605                         counter = counter +1;
00606                         
00607                         check = 1;
00608                         }
00609                     if (value == 8){
00610                         //play correct image
00611                         uLCD.cls();
00612                         uLCD.media_init();
00613                         uLCD.set_sector_address(0x0000, 0x001D);
00614                         uLCD.display_image(0,0);
00615                         FILE *wave_file;   
00616                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00617                         waver.play(wave_file);
00618                         fclose(wave_file);
00619                         wait(1);
00620                         uLCD.cls();
00621                         if (mode == 1){
00622                         nScore = nScore+1;
00623                         }
00624                         if (mode == 2){
00625                         tScore = tScore+1;
00626                         }
00627                         if (mode == 4){
00628                         cScore = cScore+1;
00629                         }
00630                         //uLCD.printf("Score: %d", Score);
00631                         wait(1);
00632                         if (mode == 1){
00633                         answer = 1;
00634                         }
00635                             counter=counter+1;
00636                         check = 1;
00637                         }
00638                     if (value == 4){
00639                         //play game over
00640                         uLCD.cls();
00641                         uLCD.media_init();
00642                         uLCD.set_sector_address(0x0000, 0x005E);
00643                         uLCD.display_image(0,0);
00644                         FILE *wave_file;   
00645                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00646                         waver.play(wave_file);
00647                         fclose(wave_file);
00648                         wait(1);
00649                         uLCD.cls();
00650                         if (mode == 4){
00651                         answer = 0;
00652                         }
00653                         counter = counter+1;
00654                         check = 1;
00655                     }
00656                 }
00657             }
00658              if (question == 7){
00659                 value = 0;
00660                 uLCD.cls();
00661                 uLCD.locate(1,2);
00662                 uLCD.printf("The best selling\nmusic single of all time is?\n\n\n");
00663                 uLCD.printf("1) Billie Jean\n");
00664                 uLCD.printf("2) White Christmas\n");
00665                 uLCD.printf("3) Candle in the \nWind\n");
00666                 while (check == 0){
00667                     int value=mpr121.read(0x00);
00668                     value +=mpr121.read(0x01)<<8;
00669                     if (value == 2){
00670                         //play game over
00671                         uLCD.cls();
00672                         uLCD.media_init();
00673                         uLCD.set_sector_address(0x0000, 0x005E);
00674                         uLCD.display_image(0,0);
00675                         FILE *wave_file;   
00676                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00677                         waver.play(wave_file);
00678                         fclose(wave_file);
00679                         wait(1);
00680                         uLCD.cls();
00681                         if (mode == 4){
00682                         answer = 0;
00683                         }
00684                         counter = counter +1;
00685                         
00686                         check = 1;
00687                         }
00688                     if (value == 8){
00689                         //play correct image
00690                         uLCD.cls();
00691                         uLCD.media_init();
00692                         uLCD.set_sector_address(0x0000, 0x001D);
00693                         uLCD.display_image(0,0);
00694                         FILE *wave_file;   
00695                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00696                         waver.play(wave_file);
00697                         fclose(wave_file);
00698                         wait(1);
00699                         uLCD.cls();
00700                         if (mode == 1){
00701                         nScore = nScore+1;
00702                         }
00703                         if (mode == 2){
00704                         tScore = tScore+1;
00705                         }
00706                         if (mode == 4){
00707                         cScore = cScore+1;
00708                         }
00709                         //uLCD.printf("Score: %d", Score);
00710                         wait(1);
00711                         if (mode == 1){
00712                         answer = 1;
00713                         }
00714                             counter=counter+1;
00715                         check = 1;
00716                         }
00717                     if (value == 4){
00718                         //play game over
00719                         uLCD.cls();
00720                         uLCD.media_init();
00721                         uLCD.set_sector_address(0x0000, 0x005E);
00722                         uLCD.display_image(0,0);
00723                         FILE *wave_file;   
00724                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00725                         waver.play(wave_file);
00726                         fclose(wave_file);
00727                         wait(1);
00728                         uLCD.cls();
00729                         if (mode == 4){
00730                         answer = 0;
00731                         }
00732                         counter = counter+1;
00733                         check = 1;
00734                     }
00735                 }
00736             }
00737              if (question == 8){
00738                 value = 0;
00739                 uLCD.cls();
00740                 uLCD.locate(1,2);
00741                  uLCD.printf("What is the \ncurrency of \nJapan?\n\n\n");
00742                 uLCD.printf("1) Pounds\n");
00743                 uLCD.printf("2) Yen\n");
00744                 uLCD.printf("3) Riki\n");
00745                 while (check == 0){
00746                     int value=mpr121.read(0x00);
00747                     value +=mpr121.read(0x01)<<8;
00748                     if (value == 2){
00749                         //play game over
00750                         uLCD.cls();
00751                         uLCD.media_init();
00752                         uLCD.set_sector_address(0x0000, 0x005E);
00753                         uLCD.display_image(0,0);
00754                         FILE *wave_file;   
00755                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00756                         waver.play(wave_file);
00757                         fclose(wave_file);
00758                         wait(1);
00759                         uLCD.cls();
00760                         if (mode == 4){
00761                         answer = 0;
00762                         }
00763                         counter = counter +1;
00764                         
00765                         check = 1;
00766                         }
00767                     if (value == 4){
00768                         //play correct image
00769                         uLCD.cls();
00770                         uLCD.media_init();
00771                         uLCD.set_sector_address(0x0000, 0x001D);
00772                         uLCD.display_image(0,0);
00773                         FILE *wave_file;   
00774                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00775                         waver.play(wave_file);
00776                         fclose(wave_file);
00777                         wait(1);
00778                         uLCD.cls();
00779                         if (mode == 1){
00780                         nScore = nScore+1;
00781                         }
00782                         if (mode == 2){
00783                         tScore = tScore+1;
00784                         }
00785                         if (mode == 4){
00786                         cScore = cScore+1;
00787                         }
00788                         //uLCD.printf("Score: %d", Score);
00789                         wait(1);
00790                         if (mode == 1){
00791                         answer = 1;
00792                         }
00793                             counter=counter+1;
00794                         check = 1;
00795                         }
00796                     if (value == 8){
00797                         //play game over
00798                         uLCD.cls();
00799                         uLCD.media_init();
00800                         uLCD.set_sector_address(0x0000, 0x005E);
00801                         uLCD.display_image(0,0);
00802                         FILE *wave_file;   
00803                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00804                         waver.play(wave_file);
00805                         fclose(wave_file);
00806                         wait(1);
00807                         uLCD.cls();
00808                         if (mode == 4){
00809                         answer = 0;
00810                         }
00811                         counter = counter+1;
00812                         check = 1;
00813                     }
00814                 }
00815             }
00816              if (question == 9){
00817                 value = 0;
00818                 uLCD.cls();
00819                 uLCD.locate(1,2);
00820                 uLCD.printf("Who was Harry \nHoudini?\n\n\n");
00821                 uLCD.printf("1)An Escape Artist\n");
00822                 uLCD.printf("2)Fighter Pilot in WWII\n");
00823                 uLCD.printf("3) Harry Potter's Cousin\n");
00824                 while (check == 0){
00825                     int value=mpr121.read(0x00);
00826                     value +=mpr121.read(0x01)<<8;
00827                     if (value == 4){
00828                         //play game over
00829                         uLCD.cls();
00830                         uLCD.media_init();
00831                         uLCD.set_sector_address(0x0000, 0x005E);
00832                         uLCD.display_image(0,0);
00833                         FILE *wave_file;   
00834                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00835                         waver.play(wave_file);
00836                         fclose(wave_file);
00837                         wait(1);
00838                         uLCD.cls();
00839                         if (mode == 4){
00840                         answer = 0;
00841                         }
00842                         counter = counter +1;
00843                         
00844                         check = 1;
00845                         }
00846                     if (value == 2){
00847                         //play correct image
00848                         uLCD.cls();
00849                         uLCD.media_init();
00850                         uLCD.set_sector_address(0x0000, 0x001D);
00851                         uLCD.display_image(0,0);
00852                         FILE *wave_file;   
00853                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00854                         waver.play(wave_file);
00855                         fclose(wave_file);
00856                         wait(1);
00857                         uLCD.cls();
00858                         if (mode == 1){
00859                         nScore = nScore+1;
00860                         }
00861                         if (mode == 2){
00862                         tScore = tScore+1;
00863                         }
00864                         if (mode == 4){
00865                         cScore = cScore+1;
00866                         }
00867                         //uLCD.printf("Score: %d", Score);
00868                         wait(1);
00869                         if (mode == 1){
00870                         answer = 1;
00871                         }
00872                             counter=counter+1;
00873                         check = 1;
00874                         }
00875                     if (value == 8){
00876                         //play game over
00877                         uLCD.cls();
00878                         uLCD.media_init();
00879                         uLCD.set_sector_address(0x0000, 0x005E);
00880                         uLCD.display_image(0,0);
00881                         FILE *wave_file;   
00882                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00883                         waver.play(wave_file);
00884                         fclose(wave_file);
00885                         wait(1);
00886                         uLCD.cls();
00887                         if (mode == 4){
00888                         answer = 0;
00889                         }
00890                         counter = counter+1;
00891                         check = 1;
00892                     }
00893                 }
00894             }
00895              if (question == 10){
00896                 value = 0;
00897                 uLCD.cls();
00898                 uLCD.locate(1,2);
00899                 uLCD.printf("What is glass \nmainly made up \nof?\n\n\n");
00900                 uLCD.printf("1) Sand\n");
00901                 uLCD.printf("2) Crystals\n");
00902                 uLCD.printf("3) Highly \nCompressed \nWater\n");
00903                 while (check == 0){
00904                     int value=mpr121.read(0x00);
00905                     value +=mpr121.read(0x01)<<8;
00906                     if (value == 4){
00907                         //play game over
00908                         uLCD.cls();
00909                         uLCD.media_init();
00910                         uLCD.set_sector_address(0x0000, 0x005E);
00911                         uLCD.display_image(0,0);
00912                         FILE *wave_file;   
00913                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00914                         waver.play(wave_file);
00915                         fclose(wave_file);
00916                         wait(1);
00917                         uLCD.cls();
00918                         if (mode == 4){
00919                         answer = 0;
00920                         }
00921                         counter = counter +1;
00922                         
00923                         check = 1;
00924                         }
00925                     if (value == 2){
00926                         //play correct image
00927                         uLCD.cls();
00928                         uLCD.media_init();
00929                         uLCD.set_sector_address(0x0000, 0x001D);
00930                         uLCD.display_image(0,0);
00931                         FILE *wave_file;   
00932                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00933                         waver.play(wave_file);
00934                         fclose(wave_file);
00935                         wait(1);
00936                         uLCD.cls();
00937                         if (mode == 1){
00938                         nScore = nScore+1;
00939                         }
00940                         if (mode == 2){
00941                         tScore = tScore+1;
00942                         }
00943                         if (mode == 4){
00944                         cScore = cScore+1;
00945                         }
00946                         //uLCD.printf("Score: %d", Score);
00947                         wait(1);
00948                         if (mode == 1){
00949                         answer = 1;
00950                         }
00951                             counter=counter+1;
00952                         check = 1;
00953                         }
00954                     if (value == 8){
00955                         //play game over
00956                         uLCD.cls();
00957                         uLCD.media_init();
00958                         uLCD.set_sector_address(0x0000, 0x005E);
00959                         uLCD.display_image(0,0);
00960                         FILE *wave_file;   
00961                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00962                         waver.play(wave_file);
00963                         fclose(wave_file);
00964                         wait(1);
00965                         uLCD.cls();
00966                         if (mode == 4){
00967                         answer = 0;
00968                         }
00969                         counter = counter+1;
00970                         check = 1;
00971                     }
00972                 }
00973             }
00974             if (question == 11){
00975                 value = 0;
00976                 uLCD.cls();
00977                 uLCD.locate(1,2);
00978                  uLCD.printf("In which city\n was the\n Titanic built?\n\n\n");
00979                 uLCD.printf("1) London\n");
00980                 uLCD.printf("2) Paris\n");
00981                 uLCD.printf("3) Belfast\n");
00982                 while (check == 0){
00983                     int value=mpr121.read(0x00);
00984                     value +=mpr121.read(0x01)<<8;
00985                     if (value == 2){
00986                         //play game over
00987                         uLCD.cls();
00988                         uLCD.media_init();
00989                         uLCD.set_sector_address(0x0000, 0x005E);
00990                         uLCD.display_image(0,0);
00991                         FILE *wave_file;   
00992                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00993                         waver.play(wave_file);
00994                         fclose(wave_file);
00995                         wait(1);
00996                         uLCD.cls();
00997                         if (mode == 4){
00998                         answer = 0;
00999                         }
01000                         counter = counter +1;
01001                         
01002                         check = 1;
01003                         }
01004                     if (value == 8){
01005                         //play wrong
01006                         uLCD.cls();
01007                         uLCD.media_init();
01008                         uLCD.set_sector_address(0x0000, 0x001D);
01009                         uLCD.display_image(0,0);
01010                         FILE *wave_file;   
01011                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
01012                         waver.play(wave_file);
01013                         fclose(wave_file);
01014                         wait(1);
01015                         uLCD.cls();
01016                         if (mode == 1){
01017                         nScore = nScore+1;
01018                         }
01019                         if (mode == 2){
01020                         tScore = tScore+1;
01021                         }
01022                         if (mode == 4){
01023                         cScore = cScore+1;
01024                         }
01025                         //uLCD.printf("Score: %d", Score);
01026                         wait(1);
01027                         if (mode == 1){
01028                         answer = 1;
01029                         }
01030                             counter=counter+1;
01031                         check = 1;
01032                         }
01033                     if (value == 4){
01034                         //play correct
01035                         uLCD.cls();
01036                         uLCD.media_init();
01037                         uLCD.set_sector_address(0x0000, 0x005E);
01038                         uLCD.display_image(0,0);
01039                         FILE *wave_file;   
01040                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01041                         waver.play(wave_file);
01042                         fclose(wave_file);
01043                         wait(1);
01044                         uLCD.cls();
01045                         if (mode == 4){
01046                         answer = 0;
01047                         }
01048                         counter = counter+1;
01049                         check = 1;
01050                     }
01051                 }
01052             }
01053 
01054              if (question == 12){
01055                 value = 0;
01056                 uLCD.cls();
01057                 uLCD.locate(1,2);
01058                  uLCD.printf("What animal has\nthe fastest \n metabolism?\n\n\n");
01059                 uLCD.printf("1) Cat\n");
01060                 uLCD.printf("2) Ostrich\n");
01061                 uLCD.printf("3) Hummingbird\n");
01062                 while (check == 0){
01063                     int value=mpr121.read(0x00);
01064                     value +=mpr121.read(0x01)<<8;
01065                     if (value == 2){
01066                         //play game over
01067                         uLCD.cls();
01068                         uLCD.media_init();
01069                         uLCD.set_sector_address(0x0000, 0x005E);
01070                         uLCD.display_image(0,0);
01071                         FILE *wave_file;   
01072                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01073                         waver.play(wave_file);
01074                         fclose(wave_file);
01075                         wait(1);
01076                         uLCD.cls();
01077                         if (mode == 4){
01078                         answer = 0;
01079                         }
01080                         counter = counter +1;
01081                         
01082                         check = 1;
01083                         }
01084                     if (value == 8){
01085                         //play wrong image
01086                         uLCD.cls();
01087                         uLCD.media_init();
01088                         uLCD.set_sector_address(0x0000, 0x001D);
01089                         uLCD.display_image(0,0);
01090                         FILE *wave_file;   
01091                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
01092                         waver.play(wave_file);
01093                         fclose(wave_file);
01094                         wait(1);
01095                         uLCD.cls();
01096                         if (mode == 1){
01097                         nScore = nScore+1;
01098                         }
01099                         if (mode == 2){
01100                         tScore = tScore+1;
01101                         }
01102                         if (mode == 4){
01103                         cScore = cScore+1;
01104                         }
01105                         //uLCD.printf("Score: %d", Score);
01106                         wait(1);
01107                         if (mode == 1){
01108                         answer = 1;
01109                         }
01110                             counter=counter+1;
01111                         check = 1;
01112                         }
01113                     if (value == 4){
01114                         //play correct image
01115                         uLCD.cls();
01116                         uLCD.media_init();
01117                         uLCD.set_sector_address(0x0000, 0x005E);
01118                         uLCD.display_image(0,0);
01119                         FILE *wave_file;   
01120                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01121                         waver.play(wave_file);
01122                         fclose(wave_file);
01123                         wait(1);
01124                         uLCD.cls();
01125                         if (mode == 4){
01126                         answer = 0;
01127                         }
01128                         counter = counter+1;
01129                         check = 1;
01130                     }
01131                 }
01132             }
01133 
01134              if (question == 13){
01135                 value = 0;
01136                 uLCD.cls();
01137                 uLCD.locate(1,2);
01138                  uLCD.printf("What is the\nlargest organ \nof the human\n body?\n\n\n");
01139                 uLCD.printf("1) Kidney\n");
01140                 uLCD.printf("2) Liver\n");
01141                 uLCD.printf("3) Brain\n");
01142                 while (check == 0){
01143                     int value=mpr121.read(0x00);
01144                     value +=mpr121.read(0x01)<<8;
01145                     if (value == 2){
01146                         //play game over
01147                         uLCD.cls();
01148                         uLCD.media_init();
01149                         uLCD.set_sector_address(0x0000, 0x005E);
01150                         uLCD.display_image(0,0);
01151                         FILE *wave_file;   
01152                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01153                         waver.play(wave_file);
01154                         fclose(wave_file);
01155                         wait(1);
01156                         uLCD.cls();
01157                         if (mode == 4){
01158                         answer = 0;
01159                         }
01160                         counter = counter +1;
01161                         
01162                         check = 1;
01163                         }
01164                     if (value == 4){
01165                         //play correct image
01166                         uLCD.cls();
01167                         uLCD.media_init();
01168                         uLCD.set_sector_address(0x0000, 0x001D);
01169                         uLCD.display_image(0,0);
01170                         FILE *wave_file;   
01171                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
01172                         waver.play(wave_file);
01173                         fclose(wave_file);
01174                         wait(1);
01175                         uLCD.cls();
01176                         if (mode == 1){
01177                         nScore = nScore+1;
01178                         }
01179                         if (mode == 2){
01180                         tScore = tScore+1;
01181                         }
01182                         if (mode == 4){
01183                         cScore = cScore+1;
01184                         }
01185                         //uLCD.printf("Score: %d", Score);
01186                         wait(1);
01187                         if (mode == 1){
01188                         answer = 1;
01189                         }
01190                             counter=counter+1;
01191                         check = 1;
01192                         }
01193                     if (value == 8){
01194                         //play wrong image
01195                         uLCD.cls();
01196                         uLCD.media_init();
01197                         uLCD.set_sector_address(0x0000, 0x005E);
01198                         uLCD.display_image(0,0);
01199                         FILE *wave_file;   
01200                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01201                         waver.play(wave_file);
01202                         fclose(wave_file);
01203                         wait(1);
01204                         uLCD.cls();
01205                         if (mode == 4){
01206                         answer = 0;
01207                         }
01208                         counter = counter+1;
01209                         check = 1;
01210                     }
01211                 }
01212             }
01213 
01214              if (question == 14){
01215                 value = 0;
01216                 uLCD.cls();
01217                 uLCD.locate(1,2);
01218                  uLCD.printf("Who was the\nfirst U.S. \nPresident \nto live in the\n white house?\n\n\n");
01219                 uLCD.printf("1) George Washington\n");
01220                 uLCD.printf("2) Thomas Jefferson\n");
01221                 uLCD.printf("3) John Adams\n");
01222                 while (check == 0){
01223                     int value=mpr121.read(0x00);
01224                     value +=mpr121.read(0x01)<<8;
01225                     if (value == 2){
01226                         //play game over
01227                         uLCD.cls();
01228                         uLCD.media_init();
01229                         uLCD.set_sector_address(0x0000, 0x005E);
01230                         uLCD.display_image(0,0);
01231                         FILE *wave_file;   
01232                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01233                         waver.play(wave_file);
01234                         fclose(wave_file);
01235                         wait(1);
01236                         uLCD.cls();
01237                         if (mode == 4){
01238                         answer = 0;
01239                         }
01240                         counter = counter +1;
01241                         
01242                         check = 1;
01243                         }
01244                     if (value == 8){
01245                         //play wrong image
01246                         uLCD.cls();
01247                         uLCD.media_init();
01248                         uLCD.set_sector_address(0x0000, 0x001D);
01249                         uLCD.display_image(0,0);
01250                         FILE *wave_file;   
01251                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
01252                         waver.play(wave_file);
01253                         fclose(wave_file);
01254                         wait(1);
01255                         uLCD.cls();
01256                         if (mode == 1){
01257                         nScore = nScore+1;
01258                         }
01259                         if (mode == 2){
01260                         tScore = tScore+1;
01261                         }
01262                         if (mode == 4){
01263                         cScore = cScore+1;
01264                         }
01265                         //uLCD.printf("Score: %d", Score);
01266                         wait(1);
01267                         if (mode == 1){
01268                         answer = 1;
01269                         }
01270                             counter=counter+1;
01271                         check = 1;
01272                         }
01273                     if (value == 4){
01274                         //play correct
01275                         uLCD.cls();
01276                         uLCD.media_init();
01277                         uLCD.set_sector_address(0x0000, 0x005E);
01278                         uLCD.display_image(0,0);
01279                         FILE *wave_file;   
01280                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01281                         waver.play(wave_file);
01282                         fclose(wave_file);
01283                         wait(1);
01284                         uLCD.cls();
01285                         if (mode == 4){
01286                         answer = 0;
01287                         }
01288                         counter = counter+1;
01289                         check = 1;
01290                     }
01291                 }
01292             }
01293 
01294 
01295 
01296 
01297              if (question == 15){
01298                 value = 0;
01299                 uLCD.cls();
01300                 uLCD.locate(1,2);
01301                  uLCD.printf("Who was the\noldest person to\n sign the\n Declaration\n of Independence?\n\n\n");
01302                 uLCD.printf("1) Thomas Jefferson\n");
01303                 uLCD.printf("2) George Washington\n");
01304                 uLCD.printf("3) Benjamin Franklin\n");
01305                 while (check == 0){
01306                     int value=mpr121.read(0x00);
01307                     value +=mpr121.read(0x01)<<8;
01308                     if (value == 2){
01309                         //play game over
01310                         uLCD.cls();
01311                         uLCD.media_init();
01312                         uLCD.set_sector_address(0x0000, 0x005E);
01313                         uLCD.display_image(0,0);
01314                         FILE *wave_file;   
01315                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01316                         waver.play(wave_file);
01317                         fclose(wave_file);
01318                         wait(1);
01319                         uLCD.cls();
01320                         if (mode == 4){
01321                         answer = 0;
01322                         }
01323                         counter = counter +1;
01324                         
01325                         check = 1;
01326                         }
01327                     if (value == 8){
01328                         //play wrong image
01329                         uLCD.cls();
01330                         uLCD.media_init();
01331                         uLCD.set_sector_address(0x0000, 0x001D);
01332                         uLCD.display_image(0,0);
01333                         FILE *wave_file;   
01334                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
01335                         waver.play(wave_file);
01336                         fclose(wave_file);
01337                         wait(1);
01338                         uLCD.cls();
01339                         if (mode == 1){
01340                         nScore = nScore+1;
01341                         }
01342                         if (mode == 2){
01343                         tScore = tScore+1;
01344                         }
01345                         if (mode == 4){
01346                         cScore = cScore+1;
01347                         }
01348                         //uLCD.printf("Score: %d", Score);
01349                         wait(1);
01350                         if (mode == 1){
01351                         answer = 1;
01352                         }
01353                             counter=counter+1;
01354                         check = 1;
01355                         }
01356                     if (value == 4){
01357                         //play correct
01358                         uLCD.cls();
01359                         uLCD.media_init();
01360                         uLCD.set_sector_address(0x0000, 0x005E);
01361                         uLCD.display_image(0,0);
01362                         FILE *wave_file;   
01363                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01364                         waver.play(wave_file);
01365                         fclose(wave_file);
01366                         wait(1);
01367                         uLCD.cls();
01368                         if (mode == 4){
01369                         answer = 0;
01370                         }
01371                         counter = counter+1;
01372                         check = 1;
01373                     }
01374                 }
01375             }
01376 
01377              if (question == 16){
01378                 value = 0;
01379                 uLCD.cls();
01380                 uLCD.locate(1,2);
01381                  uLCD.printf("How many\n paintings\ndid Vincent Van\n Gogh sell? \n\n\n");
01382                 uLCD.printf("1) One\n");
01383                 uLCD.printf("2) Two\n");
01384                 uLCD.printf("3) Three\n");
01385                 while (check == 0){
01386                     int value=mpr121.read(0x00);
01387                     value +=mpr121.read(0x01)<<8;
01388                     if (value == 4){
01389                         //play correct image
01390                         uLCD.cls();
01391                         uLCD.media_init();
01392                         uLCD.set_sector_address(0x0000, 0x005E);
01393                         uLCD.display_image(0,0);
01394                         FILE *wave_file;   
01395                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01396                         waver.play(wave_file);
01397                         fclose(wave_file);
01398                         wait(1);
01399                         uLCD.cls();
01400                         if (mode == 4){
01401                         answer = 0;
01402                         }
01403                         counter = counter +1;
01404                         
01405                         check = 1;
01406                         }
01407                     if (value == 2){
01408                         //play wrong image
01409                         uLCD.cls();
01410                         uLCD.media_init();
01411                         uLCD.set_sector_address(0x0000, 0x001D);
01412                         uLCD.display_image(0,0);
01413                         FILE *wave_file;   
01414                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
01415                         waver.play(wave_file);
01416                         fclose(wave_file);
01417                         wait(1);
01418                         uLCD.cls();
01419                         if (mode == 1){
01420                         nScore = nScore+1;
01421                         }
01422                         if (mode == 2){
01423                         tScore = tScore+1;
01424                         }
01425                         if (mode == 4){
01426                         cScore = cScore+1;
01427                         }
01428                         //uLCD.printf("Score: %d", Score);
01429                         wait(1);
01430                         if (mode == 1){
01431                         answer = 1;
01432                         }
01433                             counter=counter+1;
01434                         check = 1;
01435                         }
01436                     if (value == 8){
01437                         //play wrong image
01438                         uLCD.cls();
01439                         uLCD.media_init();
01440                         uLCD.set_sector_address(0x0000, 0x005E);
01441                         uLCD.display_image(0,0);
01442                         FILE *wave_file;   
01443                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
01444                         waver.play(wave_file);
01445                         fclose(wave_file);
01446                         wait(1);
01447                         uLCD.cls();
01448                         if (mode == 4){
01449                         answer = 0;
01450                         }
01451                         counter = counter+1;
01452                         check = 1;
01453                     }
01454                 }
01455             }
01456   }
01457                         
01458                         
01459                         
01460                 
01461                 
01462      }   
01463      else{
01464                 uLCD.printf("CONGRATS!");
01465                 wait(1);
01466             }
01467          
01468 }    
01469 }