🎹 Piano Fibo Generator & Reader 🎹


Windows :

🎹 Piano Fibo Generator & Reader :

Télécharger

🎹 Piano Fibo Generator & Reader :
Projet source C :

Télécharger

🎹 Fichiers Minuit :

Télécharger

Code source : Langage C


#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>
#include "include/fmod.h"

#define NBNOTE 61
#define MAXFIBO 20
#define MAXMUSIC 5096
#define MAXNAME 50
#define MAXTIME 155
#define MAXSAVE 512
#define MAXCONVERT 5

unsigned long long fibonacci(int valeur, unsigned long long a, unsigned long long b);
int unsignedLongLongToTabInt(unsigned long long unsignedLongLong, int* tabInt);
int intToTabChar(int valeur, char* tabChar);
int musicTabToTabInt(const char* musicTab, int* tabInt0, int* tabInt1, int* tabSleep);
void my_fflush();
void pause();
void ClearScreen();


int main() {
    //Initialisation des différents sons de piano avec la librairie FMOD
    srand(time(NULL));

    FMOD_SYSTEM* system;
    FMOD_System_Create(&system);
    FMOD_System_Init(system, 2, FMOD_INIT_NORMAL, NULL);

    FMOD_SOUND* DO_1 = NULL;
    FMOD_SOUND* DO_2 = NULL;
    FMOD_SOUND* DO_3 = NULL;
    FMOD_SOUND* DO_4 = NULL;
    FMOD_SOUND* DO_5 = NULL;
    FMOD_SOUND* DO_6 = NULL;
    FMOD_SOUND* DOd_1 = NULL;
    FMOD_SOUND* DOd_2 = NULL;
    FMOD_SOUND* DOd_3 = NULL;
    FMOD_SOUND* DOd_4 = NULL;
    FMOD_SOUND* DOd_5 = NULL;
    FMOD_SOUND* RE_1 = NULL;
    FMOD_SOUND* RE_2 = NULL;
    FMOD_SOUND* RE_3 = NULL;
    FMOD_SOUND* RE_4 = NULL;
    FMOD_SOUND* RE_5 = NULL;
    FMOD_SOUND* REd_1 = NULL;
    FMOD_SOUND* REd_2 = NULL;
    FMOD_SOUND* REd_3 = NULL;
    FMOD_SOUND* REd_4 = NULL;
    FMOD_SOUND* REd_5 = NULL;
    FMOD_SOUND* MI_1 = NULL;
    FMOD_SOUND* MI_2 = NULL;
    FMOD_SOUND* MI_3 = NULL;
    FMOD_SOUND* MI_4 = NULL;
    FMOD_SOUND* MI_5 = NULL;
    FMOD_SOUND* FA_1 = NULL;
    FMOD_SOUND* FA_2 = NULL;
    FMOD_SOUND* FA_3 = NULL;
    FMOD_SOUND* FA_4 = NULL;
    FMOD_SOUND* FA_5 = NULL;
    FMOD_SOUND* FAd_1 = NULL;
    FMOD_SOUND* FAd_2 = NULL;
    FMOD_SOUND* FAd_3 = NULL;
    FMOD_SOUND* FAd_4 = NULL;
    FMOD_SOUND* FAd_5 = NULL;
    FMOD_SOUND* SOL_1 = NULL;
    FMOD_SOUND* SOL_2 = NULL;
    FMOD_SOUND* SOL_3 = NULL;
    FMOD_SOUND* SOL_4 = NULL;
    FMOD_SOUND* SOL_5 = NULL;
    FMOD_SOUND* SOLd_1 = NULL;
    FMOD_SOUND* SOLd_2 = NULL;
    FMOD_SOUND* SOLd_3 = NULL;
    FMOD_SOUND* SOLd_4 = NULL;
    FMOD_SOUND* SOLd_5 = NULL;
    FMOD_SOUND* LA_1 = NULL;
    FMOD_SOUND* LA_2 = NULL;
    FMOD_SOUND* LA_3 = NULL;
    FMOD_SOUND* LA_4 = NULL;
    FMOD_SOUND* LA_5 = NULL;
    FMOD_SOUND* LAd_1 = NULL;
    FMOD_SOUND* LAd_2 = NULL;
    FMOD_SOUND* LAd_3 = NULL;
    FMOD_SOUND* LAd_4 = NULL;
    FMOD_SOUND* LAd_5 = NULL;
    FMOD_SOUND* SI_1 = NULL;
    FMOD_SOUND* SI_2 = NULL;
    FMOD_SOUND* SI_3 = NULL;
    FMOD_SOUND* SI_4 = NULL;
    FMOD_SOUND* SI_5 = NULL;

    FMOD_System_CreateSound(system, "sound/DO1.wav", FMOD_CREATESAMPLE, 0, &DO_1);
    FMOD_System_CreateSound(system, "sound/DO#1.wav", FMOD_CREATESAMPLE, 0, &DOd_1);
    FMOD_System_CreateSound(system, "sound/RE1.wav", FMOD_CREATESAMPLE, 0, &RE_1);
    FMOD_System_CreateSound(system, "sound/RE#1.wav", FMOD_CREATESAMPLE, 0, &REd_1);
    FMOD_System_CreateSound(system, "sound/MI1.wav", FMOD_CREATESAMPLE, 0, &MI_1);
    FMOD_System_CreateSound(system, "sound/FA1.wav", FMOD_CREATESAMPLE, 0, &FA_1);
    FMOD_System_CreateSound(system, "sound/FA#1.wav", FMOD_CREATESAMPLE, 0, &FAd_1);
    FMOD_System_CreateSound(system, "sound/SOL1.wav", FMOD_CREATESAMPLE, 0, &SOL_1);
    FMOD_System_CreateSound(system, "sound/SOL#1.wav", FMOD_CREATESAMPLE, 0, &SOLd_1);
    FMOD_System_CreateSound(system, "sound/LA1.wav", FMOD_CREATESAMPLE, 0, &LA_1);
    FMOD_System_CreateSound(system, "sound/LA#1.wav", FMOD_CREATESAMPLE, 0, &LAd_1);
    FMOD_System_CreateSound(system, "sound/SI1.wav", FMOD_CREATESAMPLE, 0, &SI_1);
    FMOD_System_CreateSound(system, "sound/DO2.wav", FMOD_CREATESAMPLE, 0, &DO_2);
    FMOD_System_CreateSound(system, "sound/DO#2.wav", FMOD_CREATESAMPLE, 0, &DOd_2);
    FMOD_System_CreateSound(system, "sound/RE2.wav", FMOD_CREATESAMPLE, 0, &RE_2);
    FMOD_System_CreateSound(system, "sound/RE#2.wav", FMOD_CREATESAMPLE, 0, &REd_2);
    FMOD_System_CreateSound(system, "sound/MI2.wav", FMOD_CREATESAMPLE, 0, &MI_2);
    FMOD_System_CreateSound(system, "sound/FA2.wav", FMOD_CREATESAMPLE, 0, &FA_2);
    FMOD_System_CreateSound(system, "sound/FA#2.wav", FMOD_CREATESAMPLE, 0, &FAd_2);
    FMOD_System_CreateSound(system, "sound/SOL2.wav", FMOD_CREATESAMPLE, 0, &SOL_2);
    FMOD_System_CreateSound(system, "sound/SOL#2.wav", FMOD_CREATESAMPLE, 0, &SOLd_2);
    FMOD_System_CreateSound(system, "sound/LA2.wav", FMOD_CREATESAMPLE, 0, &LA_2);
    FMOD_System_CreateSound(system, "sound/LA#2.wav", FMOD_CREATESAMPLE, 0, &LAd_2);
    FMOD_System_CreateSound(system, "sound/SI2.wav", FMOD_CREATESAMPLE, 0, &SI_2);
    FMOD_System_CreateSound(system, "sound/DO3.wav", FMOD_CREATESAMPLE, 0, &DO_3);
    FMOD_System_CreateSound(system, "sound/DO#3.wav", FMOD_CREATESAMPLE, 0, &DOd_3);
    FMOD_System_CreateSound(system, "sound/RE3.wav", FMOD_CREATESAMPLE, 0, &RE_3);
    FMOD_System_CreateSound(system, "sound/RE#3.wav", FMOD_CREATESAMPLE, 0, &REd_3);
    FMOD_System_CreateSound(system, "sound/MI3.wav", FMOD_CREATESAMPLE, 0, &MI_3);
    FMOD_System_CreateSound(system, "sound/FA3.wav", FMOD_CREATESAMPLE, 0, &FA_3);
    FMOD_System_CreateSound(system, "sound/FA#3.wav", FMOD_CREATESAMPLE, 0, &FAd_3);
    FMOD_System_CreateSound(system, "sound/SOL3.wav", FMOD_CREATESAMPLE, 0, &SOL_3);
    FMOD_System_CreateSound(system, "sound/SOL#3.wav", FMOD_CREATESAMPLE, 0, &SOLd_3);
    FMOD_System_CreateSound(system, "sound/LA3.wav", FMOD_CREATESAMPLE, 0, &LA_3);
    FMOD_System_CreateSound(system, "sound/LA#3.wav", FMOD_CREATESAMPLE, 0, &LAd_3);
    FMOD_System_CreateSound(system, "sound/SI3.wav", FMOD_CREATESAMPLE, 0, &SI_3);
    FMOD_System_CreateSound(system, "sound/DO4.wav", FMOD_CREATESAMPLE, 0, &DO_4);
    FMOD_System_CreateSound(system, "sound/DO#4.wav", FMOD_CREATESAMPLE, 0, &DOd_4);
    FMOD_System_CreateSound(system, "sound/RE4.wav", FMOD_CREATESAMPLE, 0, &RE_4);
    FMOD_System_CreateSound(system, "sound/RE#4.wav", FMOD_CREATESAMPLE, 0, &REd_4);
    FMOD_System_CreateSound(system, "sound/MI4.wav", FMOD_CREATESAMPLE, 0, &MI_4);
    FMOD_System_CreateSound(system, "sound/FA4.wav", FMOD_CREATESAMPLE, 0, &FA_4);
    FMOD_System_CreateSound(system, "sound/FA#4.wav", FMOD_CREATESAMPLE, 0, &FAd_4);
    FMOD_System_CreateSound(system, "sound/SOL4.wav", FMOD_CREATESAMPLE, 0, &SOL_4);
    FMOD_System_CreateSound(system, "sound/SOL#4.wav", FMOD_CREATESAMPLE, 0, &SOLd_4);
    FMOD_System_CreateSound(system, "sound/LA4.wav", FMOD_CREATESAMPLE, 0, &LA_4);
    FMOD_System_CreateSound(system, "sound/LA#4.wav", FMOD_CREATESAMPLE, 0, &LAd_4);
    FMOD_System_CreateSound(system, "sound/SI4.wav", FMOD_CREATESAMPLE, 0, &SI_4);
    FMOD_System_CreateSound(system, "sound/DO5.wav", FMOD_CREATESAMPLE, 0, &DO_5);
    FMOD_System_CreateSound(system, "sound/DO#5.wav", FMOD_CREATESAMPLE, 0, &DOd_5);
    FMOD_System_CreateSound(system, "sound/RE5.wav", FMOD_CREATESAMPLE, 0, &RE_5);
    FMOD_System_CreateSound(system, "sound/RE#5.wav", FMOD_CREATESAMPLE, 0, &REd_5);
    FMOD_System_CreateSound(system, "sound/MI5.wav", FMOD_CREATESAMPLE, 0, &MI_5);
    FMOD_System_CreateSound(system, "sound/FA5.wav", FMOD_CREATESAMPLE, 0, &FA_5);
    FMOD_System_CreateSound(system, "sound/FA#5.wav", FMOD_CREATESAMPLE, 0, &FAd_5);
    FMOD_System_CreateSound(system, "sound/SOL5.wav", FMOD_CREATESAMPLE, 0, &SOL_5);
    FMOD_System_CreateSound(system, "sound/SOL#5.wav", FMOD_CREATESAMPLE, 0, &SOLd_5);
    FMOD_System_CreateSound(system, "sound/LA5.wav", FMOD_CREATESAMPLE, 0, &LA_5);
    FMOD_System_CreateSound(system, "sound/LA#5.wav", FMOD_CREATESAMPLE, 0, &LAd_5);
    FMOD_System_CreateSound(system, "sound/SI5.wav", FMOD_CREATESAMPLE, 0, &SI_5);
    FMOD_System_CreateSound(system, "sound/DO6.wav", FMOD_CREATESAMPLE, 0, &DO_6);

    int* note[NBNOTE];

    note[0] = &DO_1;
    note[1] = &DOd_1;
    note[2] = &RE_1;
    note[3] = &REd_1;
    note[4] = &MI_1;
    note[5] = &FA_1;
    note[6] = &FAd_1;
    note[7] = &SOL_1;
    note[8] = &SOLd_1;
    note[9] = &LA_1;
    note[10] = &LAd_1;
    note[11] = &SI_1;
    note[12] = &DO_2;
    note[13] = &DOd_2;
    note[14] = &RE_2;
    note[15] = &REd_2;
    note[16] = &MI_2;
    note[17] = &FA_2;
    note[18] = &FAd_2;
    note[19] = &SOL_2;
    note[20] = &SOLd_2;
    note[21] = &LA_2;
    note[22] = &LAd_2;
    note[23] = &SI_2;
    note[24] = &DO_3;
    note[25] = &DOd_3;
    note[26] = &RE_3;
    note[27] = &REd_3;
    note[28] = &MI_3;
    note[29] = &FA_3;
    note[30] = &FAd_3;
    note[31] = &SOL_3;
    note[32] = &SOLd_3;
    note[33] = &LA_3;
    note[34] = &LAd_3;
    note[35] = &SI_3;
    note[36] = &DO_4;
    note[37] = &DOd_4;
    note[38] = &RE_4;
    note[39] = &REd_4;;
    note[40] = &MI_4;
    note[41] = &FA_4;
    note[42] = &FAd_4;
    note[43] = &SOL_4;
    note[44] = &SOLd_4;
    note[45] = &LA_4;
    note[46] = &LAd_4;
    note[47] = &SI_4;
    note[48] = &DO_5;
    note[49] = &DOd_5;
    note[50] = &RE_5;
    note[51] = &REd_5;
    note[52] = &MI_5;
    note[53] = &FA_5;
    note[54] = &FAd_5;
    note[55] = &SOL_5;
    note[56] = &SOLd_5;
    note[57] = &LA_5;
    note[58] = &LAd_5;
    note[59] = &SI_5;
    note[60] = &DO_6;

    //variables globales
    FILE* music = NULL;
    int i, j, k, sleep;
    char fichier[MAXNAME];

    //variables générateur de musiques
    unsigned long long resultat;
    int attribNote, nbChiffre, noteJouee, init, precedant, duree, fin, interPause, interGrave, grave, difGrave, resTab[MAXFIBO], saveMusic0[MAXTIME], saveMusic1[MAXTIME], saveSleep[MAXTIME];
    char menu, choix, totalDir[MAXNAME+6], convertChar[MAXCONVERT], stringFichier[MAXSAVE];

    //variable lecteur de musiques
    char musicTab[MAXMUSIC];
    int musicTabInt0[MAXMUSIC], musicTabInt1[MAXMUSIC], tabSleep[MAXMUSIC], len_music = 0;

    do {
        ClearScreen();
        printf("  ______ _ _             _____ _                      _____                           _             \n |  ____(_) |           |  __ (_)                    / ____|                         | |            \n | |__   _| |__   ___   | |__) |  __ _ _ __   ___   | |  __  ___ _ __   ___ _ __ __ _| |_ ___  _ __ \n |  __| | | '_ \\ / _ \\  |  ___/ |/ _` | '_ \\ / _ \\  | | |_ |/ _ \\ '_ \\ / _ \\ '__/ _` | __/ _ \\| '__|\n | |    | | |_) | (_) | | |   | | (_| | | | | (_) | | |__| |  __/ | | |  __/ | | (_| | || (_) | |   \n |_|    |_|_.__/ \\___/  |_|   |_|\\__,_|_| |_|\\___/   \\_____|\\___|_| |_|\\___|_|  \\__,_|\\__\\___/|_|   \n\n             _____                _           \n   ___      |  __ \\              | |          \n  ( _ )     | |__) |___  __ _  __| | ___ _ __ \n  / _ \\/\\   |  _  // _ \\/ _` |/ _` |/ _ \\ '__|\n | (_>  <   | | \\ \\  __/ (_| | (_| |  __/ |   \n  \\___/\\/   |_|  \\_\\___|\\__,_|\\__,_|\\___|_|   \n\n\n\n\n");
        printf("\t1. Generer une musique !\n");
        printf("\t2. Ouvrir une musique sauvegardee !\n");
        printf("\tq. Quitter\n\n");

        menu = getchar();
        my_fflush();
        ClearScreen();

        switch(menu) {
            case '1':
                noteJouee = 0;
                interPause = 0;
                precedant = 0;
                grave = 0;
                duree = 50 + rand()%100;
                attribNote = 12 + rand()%32;
                sleep = 550 + rand()%200;
                init = rand()%93;

                if(attribNote < 24) {
                    difGrave = 12;
                } else if(attribNote < 36) {
                    difGrave = 12 * (1 + rand()%2);
                } else if(attribNote < 48) {
                    difGrave = 12 * (1 + rand()%3);
                } else if(attribNote < 60) {
                    difGrave = 12 * (1 + rand()%4);
                }

                saveSleep[0] = sleep;

                if(duree%7 == 0) {
                    interGrave = 7;
                } else if(duree%6 == 0) {
                    interGrave = 6;
                } else if(duree%5 == 0) {
                    interGrave = 5;
                } else if(duree%4 == 0) {
                    interGrave = 4;
                } else if(duree%3 == 0) {
                    interGrave = 3;
                } else if(duree%2 == 0) {
                    interGrave == 2;
                } else {
                    interGrave = 4;
                }

                for(i = init; i <= 93; i++) {
                    if(noteJouee >= duree) break;

                    if(i == 93) i = 0;

                    resultat = fibonacci(i, 0, 1);
                    printf("                                |_______________|_______________|_______________|\n");
                    printf("\t            \t\t|               |               |               |\n");
                    if(i < 10) {
                        printf("\tVitesse: %d\t\t|   Fibo(%d) =   |    Melodie    |    Accomp     |\n", sleep,  i);
                    } else {
                        printf("\tVitesse: %d\t\t|   Fibo(%d) =  |    Melodie    |    Accomp     |\n", sleep,  i);
                    }
                    printf("                                |_______________|_______________|_______________|\n");
                    printf("                                |               |               |               |\n");
                    nbChiffre = unsignedLongLongToTabInt(resultat, resTab);

                    for(j = 0; j < nbChiffre; j++) {
                        if(noteJouee >= duree) break;

                        if(noteJouee != 0) saveSleep[noteJouee] = 0;

                        if((((precedant - resTab[j]) >= 7 ) || ((resTab[j] - precedant) >= 7)) && interPause > 25) {
                            if(rand()%2 == 0) {
                                sleep = sleep + rand()%(750 - sleep);
                                interPause = 0;
                            } else {
                                sleep = sleep - rand()%(sleep - 550);
                                interPause = 0;
                            }
                            saveSleep[noteJouee] = sleep;
                        }

                        switch(resTab[j]) {
                    case 0:
                            k = attribNote;
                            break;
                        case 1:
                            k = attribNote + 1;
                            break;
                        case 2:
                            k = attribNote + 3;
                            break;
                        case 3:
                            k = attribNote + 5;
                            break;
                        case 4:
                            k = attribNote + 6;
                            break;
                        case 5:
                            k = attribNote + 8;
                            break;
                        case 6:
                            k = attribNote + 10;
                            break;
                        case 7:
                            k = attribNote + 12;
                            break;
                        case 8:
                            k = attribNote + 13;
                            break;
                        case 9:
                            k = attribNote + 15;
                            break;
                        }
                        FMOD_System_PlaySound(system, 0, *note[k], 0, NULL);

                        printf("\t\t\t\t|\t%d\t|\t%d", resTab[j], k);

                        if(grave == interGrave) {
                            FMOD_System_PlaySound(system, 1, *note[k - difGrave], 0, NULL);
                            saveMusic1[noteJouee] = k - difGrave;
                            grave = 0;
                            printf("\t|\t%d\t|", k - difGrave);
                        } else {
                            saveMusic1[noteJouee] = -1;
                            printf("\t|\t  \t|");
                        }

                        printf("\n\t\t\t\t|\t \t|\t  \t|\t  \t|\n");

                        saveMusic0[noteJouee] = k;
                        precedant = resTab[j];
                        Sleep(sleep);
                        noteJouee++;
                        interPause++;
                        grave++;
                    }
                }
                printf("                                |_______________|_______________|_______________|\n");
                printf("\t            \t\t|               |               |               |\n");

                fin = k;
                while(fin <= 60) {
                    fin += 12;
                    Sleep(sleep);
                    FMOD_System_PlaySound(system, 0, *note[fin], 0, NULL);
                    printf("\t\t\t\t|\t \t|\t%d", fin);
                    printf("\t|\t  \t|\n");
                    printf("\t\t\t\t|\t \t|\t  \t|\t  \t|\n");
                    saveSleep[noteJouee] = 0;
                    saveMusic0[noteJouee] = fin;
                    saveMusic1[noteJouee] = -1;
                    noteJouee++;
                }
                printf("                                |_______________|_______________|_______________|\n");
                noteJouee--;
                ClearScreen();

                do {
                    printf("Souhaitez-vous sauvegarder cette musique ? [O,N]\n (format .minuit uniquement)\n\n");
                    choix = getchar();
                    ClearScreen();
                    my_fflush();
                    if (choix != 'O' && choix != 'N') {
                        printf("Merci d'entrer soit 'O' soit 'N' (oui / non)\n\n");
                    }
                } while(choix != 'O' && choix != 'N');

                if(choix == 'O') {
                    do {
                        printf("Merci d'entrer le nom de votre fichier :\n");
                        fgets(fichier, MAXNAME, stdin);

                        if(fichier[(strlen(fichier))-1] == '\n'){
                            fichier[(strlen(fichier))-1] = '\0';
                        } else {
                            my_fflush();
                        }

                        ClearScreen();
                        if((strlen(fichier)) > 50) {
                            printf("Merci de ne pas dépasser 50 caractères !\n\n");
                        }
                    } while((strlen(fichier)) > 50);

                    sprintf(totalDir, "save/");

                    strncat(fichier, ".minuit", 7);

                    strncat(totalDir, fichier, strlen(fichier));

                    music = fopen(totalDir, "w");

                    j = 0;
                    k = 0;

                    for(i = 0; i <= noteJouee; i++) {
                        nbChiffre = intToTabChar(saveMusic0[i], convertChar);

                        if(saveMusic0[i] < 10) {
                            stringFichier[k] = '0';
                            k++;
                        }

                        for(j = 0; j < nbChiffre; j++) {
                            stringFichier[k] = convertChar[j];
                            k++;
                        }

                        if(saveMusic1[i] != -1) {
                            stringFichier[k] = '&';
                            k++;

                            if(saveMusic1[i] < 10) {
                                stringFichier[k] = '0';
                                k++;
                            }

                            nbChiffre = intToTabChar(saveMusic1[i], convertChar);

                            for(j = 0; j < nbChiffre; j++) {
                                stringFichier[k] = convertChar[j];
                                k++;
                            }
                        }

                        if(saveSleep[i] != 0) {
                            stringFichier[k] = '#';
                            k++;

                            nbChiffre = intToTabChar(saveSleep[i], convertChar);

                            for(j = 0; j < nbChiffre; j++) {
                                stringFichier[k] = convertChar[j];
                                k++;
                            }
                        }
                    }

                    for(i = 0; i < k; i++) {
                        fputc(stringFichier[i], music);
                    }

                    fclose(music);
                }
                break;
            case '2':
                printf("Merci de placer votre musique dans le dossier 'save' !\n");
                printf("saisir le nom de votre musique : \n(fichier .minuit)\n");

                fgets(fichier, MAXNAME, stdin);

                if(fichier[(strlen(fichier))-1] == '\n'){
                fichier[(strlen(fichier))-1] = '\0';
                } else {
                    my_fflush();
                }

                sprintf(totalDir, "save/");

                strncat(fichier, ".minuit", 7);

                strncat(totalDir, fichier, strlen(fichier));


                music = fopen(totalDir, "r");

                if(music != NULL) {

                    printf("\nLecture de %s :\n\n", fichier);

                    printf("                                |_______________|_______________|_______________|\n");
                    printf("\t            \t\t|               |               |               |\n");
                    printf("\t            \t\t|    Melodie    |    Accomp     |    Vitesse    |\n", sleep,  i);

                    printf("                                |_______________|_______________|_______________|\n");
                    printf("                                |               |               |               |\n");

                    fgets(musicTab, MAXMUSIC, music);

                    len_music = musicTabToTabInt(musicTab, musicTabInt0, musicTabInt1, tabSleep);

                    for(i = 0; i < len_music; i++) {

                        FMOD_System_PlaySound(system, 0, *note[musicTabInt0[i]], 0, NULL);
                        printf("\t\t\t\t|\t%d\t|", musicTabInt0[i]);


                        if(musicTabInt1[i] != -1) {
                            FMOD_System_PlaySound(system, 1, *note[musicTabInt1[i]], 0, NULL);;
                            printf("\t%d\t|", musicTabInt1[i]);
                        } else {
                            printf("\t  \t|");
                        }

                        if(tabSleep[i] != 0) {
                            sleep = tabSleep[i];
                            printf("\t%d\t|", sleep);
                        } else {
                            printf("\t   \t|", sleep);
                        }

                        printf("\n\t\t\t\t|\t \t|\t  \t|\t  \t|\n");
                        Sleep(sleep);
                    }
                    fclose(music);
                } else {
                        printf("Il semblerait que vous vous soyez trompe, vous pouvez reessayer !\n");
                        pause();
                }
                break;
            case 'q':
                printf("Merci d'avoir utilise ce generateur de musique\nA bientot !");
                pause();
                return 0;
                break;
        }
    } while(1);
}

/*unsigned long long fibonacci(int valeur, unsigned long long a, unsigned long long b) {
    if(valeur == 0) {
        return(a);
    } else if(valeur == 1) {
        return(b);
    } else if(valeur == 2) {
        return(a + b);
    } else {
        return(fibonacci(valeur - 1, b, a + b));
    }
}*/

unsigned long long fibonacci(int valeur, unsigned long long a, unsigned long long b) {
    return((pow((1 + sqrt(5.0)), valeur)-pow((1 - sqrt(5.0)), valeur))/((pow(2.0, valeur)) * sqrt(5.0)));
}

int unsignedLongLongToTabInt(unsigned long long unsignedLongLong, int* tabInt) {
    double tmp = unsignedLongLong;
    int nbChiffre = 0, i;

    while(tmp >= 1) {
        tmp /= 10;
        nbChiffre++;
    }

    for(i = nbChiffre - 1; i >= 0; i--) {
        tmp = unsignedLongLong / pow(10, i);
        tabInt[nbChiffre - 1 - i] = (unsigned long long) tmp;

        tmp = tabInt[nbChiffre - 1 - i] * pow(10, i);
        unsignedLongLong -= (unsigned long long) tmp;
    }

    return(nbChiffre);
}

int intToTabChar(int valeur, char* tabChar) {
    float tmp = valeur;
    int tabInt[MAXCONVERT], nbChiffre = 0, i = 0;

    while(tmp >= 1) {
        tmp /= 10;
        nbChiffre++;
    }

    for(i = nbChiffre - 1; i >= 0; i--) {
        tmp = valeur / pow(10, i);
        tabInt[nbChiffre - 1 - i] = (int) tmp;

        tmp = tabInt[nbChiffre - 1 - i] * pow(10, i);
        valeur -= (int) tmp;
    }

    for(i = 0; i < nbChiffre; i++) {
        tabChar[i] = tabInt[i] + '0';
    }

    return(nbChiffre);
}

int musicTabToTabInt(const char* musicTab, int* tabInt0, int* tabInt1, int* tabSleep) {
    int len_musicTab = strlen(musicTab), len_music = 0, i, j = 0;


    for(i = 0; i < len_musicTab; i += 2) {


        tabInt0[j] = (((musicTab[i] - '0') * 10 ) + (musicTab[i+1] - '0'));

        if(musicTab[i+2] == '&') {
            tabInt1[j] = (((musicTab[i+3] - '0') * 10 ) + (musicTab[i+4] - '0'));

            if(musicTab[i+5] == '#') {
                tabSleep[j] = (((musicTab[i+6] - '0') * 100 ) + ((musicTab[i+7] - '0') * 10) + (musicTab[i+8] - '0'));
                i+=7;
            } else {
                tabSleep[j] = 0;
                i+=3;
            }
        } else {
            tabInt1[j] = -1;
            if(musicTab[i+2] == '#') {
                tabSleep[j] = (((musicTab[i+3] - '0') * 100 ) + ((musicTab[i+4] - '0') * 10) + (musicTab[i+5] - '0'));
                i+=4;
            } else {
                tabSleep[j] = 0;
            }
        }
        j++;
        len_music++;
    }

    return(len_music);
}

void my_fflush(void) {
    char c = 0;

    while(c != '\n') {
        c = getchar();
    }
}

void pause(void) {
    char keypressed;
    keypressed = getchar();
    if(keypressed != '\n') {
        my_fflush();
    }
}

void ClearScreen() {
    HANDLE                     hStdOut;
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    DWORD                      count;
    DWORD                      cellCount;
    COORD                      homeCoords = { 0, 0 };

    hStdOut = GetStdHandle( STD_OUTPUT_HANDLE );
    if (hStdOut == INVALID_HANDLE_VALUE) return;

    if (!GetConsoleScreenBufferInfo( hStdOut, &csbi )) return;
    cellCount = csbi.dwSize.X *csbi.dwSize.Y;

    if (!FillConsoleOutputCharacter(
    hStdOut,
    (TCHAR) ' ',
    cellCount,
    homeCoords,
    &count
    )) return;

    if (!FillConsoleOutputAttribute(
    hStdOut,
    csbi.wAttributes,
    cellCount,
    homeCoords,
    &count
    )) return;

    SetConsoleCursorPosition( hStdOut, homeCoords );
}                              
                


Éditeur utilisé : Code::Block

Logo Code::Blocks

Site officiel C::B

Librairie audio utilisée: FMOD (api)

Logo FMOD

Site officiel FMOD

Coloration synthaxique du code source réalisée avec PRISM



Site officiel PRISM

Comptes-Rendus :



Télécharger