/******************************************************************************
main : point d'entrée du programme.
******************************************************************************/
int main()
{
/* variables locales */
char buffer[256];
int nId, nChoice, nBytesWritten, nBytesRead;
/* demande du numéro du port COM */
printf("Entrez le numero du port COM : ");
scanf("%d", &nId);
/* tentative d'ouverture */
printf("Ouverture et configuration du port COM%d...\r\n", nId);
if(!OpenCOM(nId)) return -1;
printf("...OK\r\n");
/* boucle tant que l'on ne quitte pas */
do
{
/* menu */
printf("\r\n");
printf("1 : Envoyer des donnees.\r\n");
printf("2 : Recevoir des donnees.\r\n");
printf("3 : Quitter.\r\n");
printf("Choix : ");
scanf("%d", &nChoice);
/* enoyer des données */
if(nChoice == 1)
{
printf("\r\n");
printf("Donnees a envoyer :\r\n");
fflush(stdin);
gets(buffer);
printf("\r\n");
printf("Envoi des donnees...\r\n");
if(WriteCOM(buffer, strlen(buffer), &nBytesWritten))
printf("%d octet(s) envoye(s).\r\n", nBytesWritten);
else
printf("Erreur lors de l'envoi.\r\n");
}
/* recevoir des données */
if(nChoice == 2)
{
printf("\r\n");
printf("Reception de donnees...\r\n");
if(ReadCOM(buffer, sizeof(buffer)-1, &nBytesRead))
{
buffer[nBytesRead] = '\0';
printf("%d octet(s) recu(s) :\r\n%s\r\n", nBytesRead, buffer);
}
else
printf("Erreur lors de la réception.\r\n");
}
}while(nChoice != 3);
/* fermeture du port COM et retour */
CloseCOM();
return 0;
}
//---------------------------------------------------------------
// Description:
// Attept to open a com port.
// portnum - number 0 to MAX_PORTNUM-1. This number is provided to
// indicate the symbolic port number.
// port_zstr - the string of the port to be used
// Returns FALSE if unsuccessful and TRUE if successful.
//
SMALLINT OpenCOM(int portnum, char *port_zstr)
{
int i;
for(i=0;i<4;i++)
port[i] = port_zstr[i];
// Check if port has already been opened
if (ComID[portnum] < 0) // Not opened
{
// Obtain port id
ComID[portnum] = OpenComm(port_zstr,1024,1024);
if (ComID[portnum] < 0)
{
OWERROR(OWERROR_GET_SYSTEM_RESOURCE_FAILED);
return FALSE;
}
}
else
{
return TRUE; // Already opened
}
if(!SetupCOM(portnum,CBR_9600)) // Reset unsuccessful
{
CloseCOM(portnum);
OWERROR(OWERROR_SYSTEM_RESOURCE_INIT_FAILED);
return FALSE;
}
return TRUE;
}
//---------------------------------------------------------------------------
// Attempt to acquire a 1-Wire net using a com port and a DS2480 based
// adapter.
//
// 'portnum' - number 0 to MAX_PORTNUM-1. This number was provided to
// OpenCOM to indicate the port number.
// 'port_zstr' - zero terminated port name. For this platform
// use format COMX where X is the port number.
// 'return_msg' - zero terminated return message.
//
// Returns: TRUE - success, COM port opened
//
int owAcquire(int portnum, char *port_zstr, char *return_msg)
{
int cnt=0;
portname[portnum][0] = 0;
// attempt to open the communications port
if (OpenCOM(portnum,port_zstr))
cnt += sprintf(&return_msg[cnt],"%s opened\n",port_zstr);
else
{
cnt += sprintf(&return_msg[cnt],"Could not open port %s,"
" aborting.\nClosing port %s.\n",port_zstr,port_zstr);
return FALSE;
}
// detect DS2480
if (DS2480Detect(portnum))
cnt += sprintf(&return_msg[cnt],"DS2480-based adapter detected\n");
else
{
cnt += sprintf(&return_msg[cnt],"DS2480-based adapter not detected, aborting program\n");
cnt += sprintf(&return_msg[cnt],"Closing port %s.\n",port_zstr);
CloseCOM(portnum);
return FALSE;
}
// success
sprintf(portname[portnum],"%s",port_zstr);
return TRUE;
}
//-------------------------------------------------------------------
// Description:
// Send a break on the com port for "len" msec
//
// portnum - number 0 to MAX_PORTNUM-1. This number is provided to
// indicate the symbolic port number.
//
void BreakCOM(int portnum)
{
// start the reset pulse
SetCommBreak(ComID[portnum]);
// delay
msDelay(2);
// clear the reset pulse and return
// PROGRAMMER'S NOTE: ClearCommBreak is returning 24:an undefined code
ClearCommBreak(ComID[portnum]);
// Win3.1 bug, close and then open port
CloseCOM(portnum);
OpenCOM(portnum,&port[0]);
}
//---------------------------------------------------------------------------
// Attempt to acquire a 1-Wire net using a com port and a DS2480 based
// adapter.
//
// 'portnum' - number 0 to MAX_PORTNUM-1. This number was provided to
// OpenCOM to indicate the port number.
// 'port_zstr' - zero terminated port name. For this platform
// use format COMX where X is the port number.
//
// Returns: TRUE - success, COM port opened
//
// exportable functions defined in ownetu.c
SMALLINT owAcquire(int portnum, char *port_zstr)
{
// attempt to open the communications port
if (OpenCOM(portnum,port_zstr) < 0)
{
OWERROR(OWERROR_OPENCOM_FAILED);
return FALSE;
}
// detect DS2480
if (!DS2480Detect(portnum))
{
CloseCOM(portnum);
//OWERROR(OWERROR_DS2480_NOT_DETECTED);
return FALSE;
}
return TRUE;
}
//---------------------------------------------------------------------------
// Attempt to acquire a 1-Wire net using a com port and a DS2480 based
// adapter.
//
// 'port_zstr' - zero terminated port name. For this platform
// use format COMX where X is the port number.
//
// Returns: valid handle, or -1 if an error occurred
//
// exportable functions defined in ownetu.c
//
int owAcquireEx(char *port_zstr)
{
int portnum;
// attempt to open the communications port
if ((portnum = OpenCOMEx(port_zstr)) < 0)
{
OWERROR(OWERROR_OPENCOM_FAILED);
return -1;
}
// detect DS2480
if (!DS2480Detect(portnum))
{
CloseCOM(portnum);
OWERROR(OWERROR_DS2480_NOT_DETECTED);
return -1;
}
return portnum;
}
//---------------------------------------------------------------------------
// Release the previously acquired a 1-Wire net.
//
// 'portnum' - number 0 to MAX_PORTNUM-1. This number was provided to
// OpenCOM to indicate the port number.
//
void owRelease(int portnum)
{
CloseCOM(portnum);
}
int jeu(SDL_Surface* ecran,int choix,int difficulte,int ArduinoClavier)
{
SDL_Event event; //pour pouvoir gerer les events
SDL_ShowCursor(SDL_DISABLE);//On n'affiche plus le curseur
SDL_Surface *imageDeFond = NULL, *Note = NULL, *Note_do = NULL, *Note_re = NULL, *Note_mi = NULL, *Note_fa = NULL, *Note_sol = NULL, *Note_la = NULL, *Note_si = NULL; //Initialisation des images : on crée un pointeur pour chaque image auquel on met la valeur NULL
SDL_Rect positionFond,positionNote[TAILLE_MAX], positionNote_do,positionNote_re,positionNote_mi,positionNote_fa,positionNote_sol,positionNote_la,positionNote_si; //Initialisation des positions des images
//Initialisation positions x et y
int i; for(i=0;i<TAILLE_MAX;i++)
{positionNote[i].x=0; positionNote[i].y=0;} //Initialisation de TOUTES les notes du morceau
positionNote_do.y = positionNote_re.y = positionNote_mi.y = positionNote_fa.y = positionNote_sol.y = positionNote_la.y = positionNote_si.y = 658;
positionNote_do.x = 265;
positionNote_re.x = 408;
positionNote_mi.x = 548;
positionNote_fa.x = 690;
positionNote_sol.x = 834;
positionNote_la.x = 973;
positionNote_si.x = 1117;
positionFond.x = 0;
positionFond.y = 0;
imageDeFond = SDL_LoadBMP("images/fond.bmp");//on indique ou est l'image de fond
//Images
Note = SDL_LoadBMP("images/notes/note.bmp") ;
Note_do = SDL_LoadBMP("images/notes/do.bmp");
Note_re = SDL_LoadBMP("images/notes/re.bmp");
Note_mi = SDL_LoadBMP("images/notes/mi.bmp");
Note_fa = SDL_LoadBMP("images/notes/fa.bmp");
Note_sol = SDL_LoadBMP("images/notes/sol.bmp");
Note_la = SDL_LoadBMP("images/notes/la.bmp");
Note_si = SDL_LoadBMP("images/notes/si.bmp");
SDL_SetColorKey(Note, SDL_SRCCOLORKEY, SDL_MapRGB(Note->format, 0,0, 255));//transparence
//
FILE* fichier = NULL;//pour lire la "partition"
/***********Musique***************
*********************************/
FMOD_SYSTEM *system;
FMOD_SOUND *musique;//musique :/
FMOD_RESULT resultat;
FMOD_System_Create(&system);
FMOD_System_Init(system, 1, FMOD_INIT_NORMAL, NULL);
/* On ouvre la musique en fonction du choix et on ouvre la partition qui correspond (c'est gros pour pas grand chose)*/
switch(choix)
{
case 0 :
resultat = FMOD_System_CreateSound(system, "musiques/FrereJacques.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/FrereJacques.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 1 :
resultat = FMOD_System_CreateSound(system, "musiques/Muse.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Muse.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 2 :
resultat = FMOD_System_CreateSound(system, "musiques/AuClairDeLaLune.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/AuClairDeLaLune.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 3 :
resultat = FMOD_System_CreateSound(system, "musiques/Titanic.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Titanic.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 4 :
resultat = FMOD_System_CreateSound(system, "musiques/MJ.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/MJ.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 5 :
resultat = FMOD_System_CreateSound(system, "musiques/Clocks.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Clocks.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 6 :
resultat = FMOD_System_CreateSound(system, "musiques/Laputa.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Laputa.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 7 :
resultat = FMOD_System_CreateSound(system, "musiques/YMCA.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/YMCA.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 8 :
resultat = FMOD_System_CreateSound(system, "musiques/Changes.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Changes.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 10 :
resultat = FMOD_System_CreateSound(system, "musiques/Dancing_in_the_Dark.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Dancing_in_the_Dark.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 11 :
resultat = FMOD_System_CreateSound(system, "musiques/Born_to_Run.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Born_to_Run.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 12 :
resultat = FMOD_System_CreateSound(system, "musiques/Bruno Mars.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Bruno Mars.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 13 :
resultat = FMOD_System_CreateSound(system, "musiques/Bad day.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Bad day.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 15 :
resultat = FMOD_System_CreateSound(system, "musiques/The Fray.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/The Fray.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 16 :
resultat = FMOD_System_CreateSound(system, "musiques/Led Zep.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Led Zep.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 17 :
resultat = FMOD_System_CreateSound(system, "musiques/Naruto.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Naruto.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 18 :
resultat = FMOD_System_CreateSound(system, "musiques/Somebody to love - Queen.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Somebody to love - Queen.txt", "r"); //Le fichier texte qui contient la "partition"
break;
case 19 :
resultat = FMOD_System_CreateSound(system, "musiques/Viva.mid", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
fichier = fopen("musiques/Viva.txt", "r"); //Le fichier texte qui contient la "partition"
break;
default:
break;
}
if (resultat != FMOD_OK)//verification que la musique marche
{
fprintf(stderr, "Impossible de lire le fichier audio.wav\n");
exit(EXIT_FAILURE);
}
//Bruit pour le fail (on est obligé de créer un autre systeme pour pas arreter la musique)
FMOD_SYSTEM *systemf;
FMOD_SOUND *fail = NULL;
FMOD_System_CreateSound(systemf, "fail.wav", FMOD_CREATESAMPLE, 0, &fail);
FMOD_RESULT resultatf;
/* Création et initialisation d'un objet système */
FMOD_System_Create(&systemf);
FMOD_System_Init(systemf, 1, FMOD_INIT_NORMAL, NULL);
/* Chargement du son et vérification du chargement */
resultatf = FMOD_System_CreateSound(system, "fail.wav", FMOD_CREATESAMPLE, 0, &fail);
if (resultatf != FMOD_OK)
{
fprintf(stderr, "Impossible de lire le fichier audio.wav\n");
exit(EXIT_FAILURE);
}
/****************************
Initialisation pour le texte
******************************/
char caracteres[20] = "",caracteres2[20] = ""; // Tableau de char suffisamment grand pour le score
TTF_Init(); //Initialisation de la banque de donnée pour le texte
int compteur=0; //Pour le score
SDL_Surface *score = NULL;
SDL_Rect position;
TTF_Font *police = NULL, *police2 = NULL; //TTF_OpenFont doit stocker son résultat dans une variable de type TTF_Font
SDL_Color couleurNoire = {0, 0, 0}; //couleur police => noir
police = TTF_OpenFont("police.ttf", 70);//police choisie, taille police
police2 = TTF_OpenFont("score.ttf", 70);//police choisie, taille police
//////////////////////////////////////////////
/***************************************************
+Lecture du fichier texte (Yacine)
+On met les notes a leur place (do,ré...)
en fonction de la difficulté
**************************************************/
char chaine[TAILLE_MAX]="";
int debut[TAILLE_MAX ];
int note[TAILLE_MAX ];
int tempsFin = 0 ;
int j=0,compteurNotes=0;
while (fgets(chaine, TAILLE_MAX, fichier) != NULL) //tant que le fichier n'a pas été totalement parcouru (fgets s'incremente automatiquement)
{
///Easy
if (difficulte==0){
if (compteurNotes%3==0)//Pour la difficulté, on ne prend qu'une note sur 3 quand on a choisi l'option facile
{
sscanf(chaine, "%d - %d", &debut[j], ¬e[j]); // recupere la note et la date
switch (note[j])//On met en place les notes
{
case 0 : //do
positionNote[j].x = 250;
break;
case 1 : //ré
positionNote[j].x = 395;
break;
case 2 : //mi
positionNote[j].x = 525;
break;
case 3 : //fa
positionNote[j].x = 680;
break;
case 4 : //sol
positionNote[j].x = 820;
break;
case 5 : //la
positionNote[j].x = 960;
break;
case 6 : //si
positionNote[j].x = 1100;
break;
case 8 : // Pour la fin
tempsFin = debut[j];
positionNote[j].x = 20000;//pour pas afficher la note
default :
break;
}
j++;
}
compteurNotes++;
}
///Normal
if (difficulte==1){
if (compteurNotes%2==0)//Pour la difficulté, on ne prend qu'une note sur deux quand on a choisi l'option facile
{
sscanf(chaine, "%d - %d", &debut[j], ¬e[j]); // recupere la note et la date
switch (note[j])//On met en place les notes
{
case 0 : //do
positionNote[j].x = 250;
break;
case 1 : //ré
positionNote[j].x = 395;
break;
case 2 : //mi
positionNote[j].x = 525;
break;
case 3 : //fa
positionNote[j].x = 680;
break;
case 4 : //sol
positionNote[j].x = 820;
break;
case 5 : //la
positionNote[j].x = 960;
break;
case 6 : //si
positionNote[j].x = 1100;
break;
case 8 : // Pour la fin
tempsFin = debut[j];
positionNote[j].x = 20000;//pour pas afficher la note
default :
break;
}
j++;
}
compteurNotes++;
}
///Difficile
if (difficulte==2){
//On prend toutes les notes
sscanf(chaine, "%d - %d", &debut[j], ¬e[j]); // recupere la note et la date
switch (note[j])//On met en place les notes
{
case 0 : //do
positionNote[j].x = 250;
break;
case 1 : //ré
positionNote[j].x = 395;
break;
case 2 : //mi
positionNote[j].x = 525;
break;
case 3 : //fa
positionNote[j].x = 680;
break;
case 4 : //sol
positionNote[j].x = 820;
break;
case 5 : //la
positionNote[j].x = 960;
break;
case 6 : //si
positionNote[j].x = 1100;
break;
case 8 : // Pour la fin
tempsFin = debut[j];
positionNote[j].x = 20000;//pour pas afficher la note
default :
break;
}
j++;
}
}
//////////////////////////////////////////////
int pourcent[TAILLE_MAX] = {0},pourcentFinal=0,totalNotes=0;//Pour le pourcentage de réussite
int k=0;//notes 1,2,3....
int tempsDebut=SDL_GetTicks();//SDL_GetTicks donne le temps qu'il s'est écoulé depuis le lancement du programme, on retire donc le temps qu'il s'est écoulé entre le lancement et le début du morceau
int a=0,z=0,e=0,r=0,t=0,y=0,u=0;//notes
int tempsPrecedent = 0, tempsActuel = 0, tempsNote[7]; //Timer (temps note permet de savoir a quel instant t la note a été jouée
int continuer = 1;
//Boucle jeu
if (ArduinoClavier) arduino(1);//On lance arduino pour avoir le numéro port série qui correspond
while (continuer)
{
/* On joue la musique au bon moment de manière à ce qu'elle soit synchronisée avec les notes qui défilent */
if ((tempsActuel>=2700)&&(tempsActuel<=2750))FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, musique, 0,NULL);
/* On efface l'écran */
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255,255, 255));//255,255, 255 veut dire qu'on met un ecran noir
/* On remet le fond */
SDL_BlitSurface(imageDeFond, NULL, ecran, &positionFond);
tempsActuel = SDL_GetTicks() - tempsDebut; //temps
/************************************************
+ On affiche les notes
+ On fait descendre les notes le long des lignes
J'ai galeré pour ca !
*************************************************/
if(tempsActuel>=debut[k+1]) k++; // passage à la note suivante
int l=k;
do
{
if (tempsActuel>=debut[0]) positionNote[l].y= positionNote[l].y+tempsActuel/10*2-tempsPrecedent/10*2;//descente de la note en utilisant le temps comme réference (elle met du coup 2.7sec a desendre) (la condition corrige le bug de la 1ere note)
if (positionNote[l].y>575) positionNote[l].y=10000; // si la note arrive en bas on la fait "disparaitre"
SDL_BlitSurface(Note, NULL, ecran, &positionNote[l]);//on affiche les notes
l--;
}while(l>=0);
///La boucle do while est la car il faut la faire au moins une fois quand il n'y a qu'un seule note
///Pour afficher les notes précédentes (sinon on a qu'une seule note affichée)
/*Pour sortir du morceau à la fin*/
if (tempsActuel >= tempsFin) continuer = 0;
///
tempsPrecedent = tempsActuel; // comme on utilise le temps pour la boucle d'avant on le met ici (on pourrait le mettre à la toute fin, ce qui serait plus logique mais ici on comprend mieux)
/**************************************************************
*************************************************************
Fonction pour les touches
***********************************************************
**********************************************************/
/******************************************************
Switch pour savoir quelle touche a étée enfoncée. Si
une touche est enfoncée on donne a la variable la valeur
1 et on enregistre le temps a laquelle la note a été
"jouée"
*******************************************************/
SDL_PollEvent(&event);
switch(event.type)
{
case SDL_QUIT:
exit(EXIT_FAILURE);
break;
case SDL_KEYDOWN: /* Si appui sur une touche*/
switch(event.key.keysym.sym)
{
case SDLK_q: //a
a=1;
tempsNote[0]=SDL_GetTicks() - tempsDebut;
break;
case SDLK_w: //z
z=1;
tempsNote[1]=SDL_GetTicks() - tempsDebut;
break;
case SDLK_e: //e
e=1;
tempsNote[2]=SDL_GetTicks() - tempsDebut;
break;
case SDLK_r: //r
r=1;
tempsNote[3]=SDL_GetTicks() - tempsDebut;
break;
case SDLK_t: //t
t=1;
tempsNote[4]=SDL_GetTicks() - tempsDebut;
break;
case SDLK_y: //y
y=1;
tempsNote[5]=SDL_GetTicks() - tempsDebut;
break;
case SDLK_u: //u
u=1;
tempsNote[6]=SDL_GetTicks() - tempsDebut;
break;
case SDLK_ESCAPE:
continuer=0;
break;
default:
break;
}
break;
}
/*****************************************************************
On a donné à une variable la valeur 1 si l'evenement a été
réalisé, pour que deux évenements soient pris en compte en même
temps on laisse l'action que provoque l'evenement durer 250ms
(on utlise le temps enregistré avant pour savoir quand 250ms
sont écoulées)
ce qui donne l'impression que les evenements sont simultannés
Si la variable=0, l'action n'est pas réalisée
******************************************************************/
if (a)
{
SDL_BlitSurface(Note_do, NULL, ecran, &positionNote_do);
if(tempsActuel-tempsNote[0]>250) a=0;
}
if (z)
{
SDL_BlitSurface(Note_re, NULL, ecran, &positionNote_re);
if(tempsActuel-tempsNote[1]>250) z=0;
}
if (e)
{
SDL_BlitSurface(Note_mi, NULL, ecran, &positionNote_mi);
if(tempsActuel-tempsNote[2]>250) e=0;
}
if (r)
{
SDL_BlitSurface(Note_fa, NULL, ecran, &positionNote_fa);
if(tempsActuel-tempsNote[3]>250) r=0;
}
if (t)
{
SDL_BlitSurface(Note_sol, NULL, ecran, &positionNote_sol);
if(tempsActuel-tempsNote[4]>250) t=0;
}
if (y)
{
SDL_BlitSurface(Note_la, NULL, ecran, &positionNote_la);
if(tempsActuel-tempsNote[5]>250) y=0;
}
if (u)
{
SDL_BlitSurface(Note_si, NULL, ecran, &positionNote_si);
if(tempsActuel-tempsNote[6]>250) u=0;
}
/*****************************************************************
Cette partie permet de déterminer quels boutons poussoirs sont enfoncés a partir du nombre
renvoyé par la fonction arduino.
Si un bouton est enfoncé on lui attribue un caractère propre, ainsi lors des tests de succès
cette information sera gérée exactement comme les évènements au clavier.
Bugs incompréhensibles liés a l'ajout d'arduino:
On ne peux plus quitter la partie en cours (parfois si)
Au début de certains morceaux des notes bizarres s'affichent
mais cela revient a la normale après 2-3 secondes.
Auteur : Yacine Saoudi
******************************************************************/
if (ArduinoClavier)
{
int arduinoIu=0;
arduinoIu=arduino(0);
char boutonArd[8];
sprintf(boutonArd, "%d", arduinoIu);
//on transforme le nombre stocké dans arduinoIu en chaine de caractère.
//cela permet de tester la présence ou non d'un caractère dans celle ci:
if(strstr(boutonArd, "1")!=NULL) a=1;
if(strstr(boutonArd, "2")!=NULL) z=1;
if(strstr(boutonArd, "3")!=NULL) e=1;
if(strstr(boutonArd, "4")!=NULL) r=1;
if(strstr(boutonArd, "5")!=NULL) t=1;
if(strstr(boutonArd, "6")!=NULL) y=1;
if(strstr(boutonArd, "7")!=NULL) u=1;
}
/***********************************************************************
Fonction réussit ou raté (si la note est "jouée" au bon moment)
************************************************************************/
l=k;//on teste toutes les notes qui on étées affichées
do
{
//réussi
if ((a)&&(positionNote[l].y>550)&&(positionNote[l].y<580)&&(positionNote[l].x == 250)) {compteur++; pourcent[l]=1;} //compteur => score
if ((z)&&(positionNote[l].y>550)&&(positionNote[l].y<580)&&(positionNote[l].x == 395)) {compteur++; pourcent[l]=1;} //pourcent => la note spécifique l est réussie ou non (1= réussi)
if ((e)&&(positionNote[l].y>550)&&(positionNote[l].y<580)&&(positionNote[l].x == 525)) {compteur++; pourcent[l]=1;}
if ((r)&&(positionNote[l].y>550)&&(positionNote[l].y<580)&&(positionNote[l].x == 680)) {compteur++; pourcent[l]=1;}
if ((t)&&(positionNote[l].y>550)&&(positionNote[l].y<580)&&(positionNote[l].x == 820)) {compteur++; pourcent[l]=1;}
if ((y)&&(positionNote[l].y>550)&&(positionNote[l].y<580)&&(positionNote[l].x == 960)) {compteur++; pourcent[l]=1;}
if ((u)&&(positionNote[l].y>550)&&(positionNote[l].y<580)&&(positionNote[l].x == 1100)) {compteur++; pourcent[l]=1;}
//fail
/*
if ((a==0)&&(positionNote[l].y>560)&&(positionNote[l].y<570)&&(positionNote[l].x == 250)) FMOD_System_PlaySound(systemf, FMOD_CHANNEL_FREE, fail, 0, NULL);
if ((z==0)&&(positionNote[l].y>560)&&(positionNote[l].y<570)&&(positionNote[l].x == 395)) FMOD_System_PlaySound(systemf, FMOD_CHANNEL_FREE, fail, 0, NULL);
if ((e==0)&&(positionNote[l].y>560)&&(positionNote[l].y<570)&&(positionNote[l].x == 525)) FMOD_System_PlaySound(systemf, FMOD_CHANNEL_FREE, fail, 0, NULL);
if ((r==0)&&(positionNote[l].y>560)&&(positionNote[l].y<570)&&(positionNote[l].x == 680)) FMOD_System_PlaySound(systemf, FMOD_CHANNEL_FREE, fail, 0, NULL);
if ((t==0)&&(positionNote[l].y>560)&&(positionNote[l].y<570)&&(positionNote[l].x == 820)) FMOD_System_PlaySound(systemf, FMOD_CHANNEL_FREE, fail, 0, NULL);
if ((y==0)&&(positionNote[l].y>560)&&(positionNote[l].y<570)&&(positionNote[l].x == 960)) FMOD_System_PlaySound(systemf, FMOD_CHANNEL_FREE, fail, 0, NULL);
if ((u==0)&&(positionNote[l].y>560)&&(positionNote[l].y<570)&&(positionNote[l].x == 1100)) FMOD_System_PlaySound(systemf, FMOD_CHANNEL_FREE, fail, 0, NULL); //son de fausse note
*/
l--;
}while(l>=0); //j'aime bien les do while (mêmes raisons qu'au dessus)
/***********************************
Fonction pour le texte, ici le score
et le nom du morceau
************************************/
//En cas d'erreur (plus propre)
if(TTF_Init() == -1)
{
fprintf(stderr, "Erreur d'initialisation de TTF_Init : %s\n", TTF_GetError());
exit(EXIT_FAILURE);
}
/*score*/
/* Écriture du texte dans la SDL_Surface texte en mode Solid (car il change souvent)*/
sprintf(caracteres, "Score : %d", compteur);
SDL_FreeSurface(score);//On efface la surface précédente (sinon ca prend 2go de RAM)
score = TTF_RenderText_Solid(police, caracteres, couleurNoire);
//Position score//
position.x = 20;
position.y = 450;
SDL_BlitSurface(score, NULL, ecran, &position); /* Blit du texte*/
/*titre*/
/* Titre en fonction du choix */
switch (choix)
{
case 0 :
sprintf(caracteres2, "Frère Jacques");
break;
case 1 :
sprintf(caracteres2, "Starlight - Muse");
break;
case 2 :
sprintf(caracteres2, "Au Clair de la Lune");
break;
case 3 :
sprintf(caracteres2, "Titanic");
break;
case 4 :
sprintf(caracteres2, "Black or White - MJ");
break;
case 5 :
sprintf(caracteres2, "Clocks - Coldplay");
break;
case 6 :
sprintf(caracteres2, "Laputa");
break;
case 7 :
sprintf(caracteres2, "YMCA");
break;
case 8 :
sprintf(caracteres2, "Changes");
break;
case 10 :
sprintf(caracteres2, "Dancing in the Dark");
break;
case 11 :
sprintf(caracteres2, "Born to Run");
break;
case 12 :
sprintf(caracteres2, "Just the way you are");
break;
case 13 :
sprintf(caracteres2, "Bad day");
break;
case 15 :
sprintf(caracteres2, "The Fray");
break;
case 16 :
sprintf(caracteres2, "Starway to heaven");
break;
case 17 :
sprintf(caracteres2, "Naruto");
break;
case 18 :
sprintf(caracteres2, "Somebody to love - Queen");
break;
case 19 :
sprintf(caracteres2, "Viva la Vida - Coldplay");
break;
default :
break;
}
SDL_FreeSurface(score);//On efface la surface précédente (sinon ca prend 2go de RAM)
score = TTF_RenderText_Solid(police2, caracteres2, couleurNoire);
//Position score//
position.x = 20;
position.y = 60;
SDL_BlitSurface(score, NULL, ecran, &position); /* Blit du texte*/
////////////////////////////////////////////////////////////////////////////////////////
/* On met à jour l'affichage */
SDL_Flip(ecran);
if (continuer==0) CloseCOM ();//On ferme le port série
}
/******************************************************
Fonction pour obtenir le pourcentage de réussite
On utilise la variable pourcent (faire une vraie fonction
de ca serait facile mais
inutile)
Bug a corriger : Si on finit pas le morceau le pourcentage
est faux (narmol)
*****************************************************/
for(totalNotes=0;totalNotes<k;totalNotes++)
{
if (pourcent[totalNotes]==1) pourcentFinal++;
}
pourcentFinal=pourcentFinal*100/totalNotes;//on fait le pourcentage (il faut finir le morceau pour que le pourcentage soit juste)
///////////////////////////////////////////
/*Sortie de boucle*/
/////////////////////////////////////////
//Libération de l'espace
//images
SDL_FreeSurface(imageDeFond);
SDL_FreeSurface(Note);
SDL_FreeSurface(Note_do);
SDL_FreeSurface(Note_re);
SDL_FreeSurface(Note_mi);
SDL_FreeSurface(Note_fa);
SDL_FreeSurface(Note_sol);
SDL_FreeSurface(Note_la);
SDL_FreeSurface(Note_si);
//pour la musique
FMOD_Sound_Release(musique);
FMOD_Sound_Release(fail);
FMOD_System_Close(system);
FMOD_System_Release(system);
//return compteur;//le score (le pourcentage est plus interessant)
return pourcentFinal;//le pourcentage de réussite
}
//---------------------------------------------------------------------------
// Release the previously acquired a 1-Wire net.
//
// 'portnum' - number 0 to MAX_PORTNUM-1. This number was provided to
// OpenCOM to indicate the port number.
// 'return_msg' - zero terminated return message.
//
void owRelease(int portnum, char *return_msg)
{
// close the communications port
sprintf(return_msg,"Closing port %s.\n",portname[portnum]);
CloseCOM(portnum);
}
