diff options
| author | Benjamin Chausse <benjamin@chausse.xyz> | 2023-04-08 13:36:34 -0400 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2023-04-08 13:36:34 -0400 |
| commit | c3946e1a73aec0eb75ff4301dc42e1a2a71aab60 (patch) | |
| tree | 9bfd6b6df4666491295b30088a6bf7bec6f61757 /main.cpp | |
| parent | 0fd63dfa5dfcac42a45f0b247e8461b4b969d6f7 (diff) | |
| parent | 3180cb7584c037463ee5c2047aea3e3ed0f0b364 (diff) | |
Diffstat (limited to 'main.cpp')
| -rw-r--r-- | main.cpp | 1114 |
1 files changed, 1114 insertions, 0 deletions
diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..e6dda70 --- /dev/null +++ b/main.cpp @@ -0,0 +1,1114 @@ +#include <iostream>
+#include <chrono>
+#include <cmath>
+#include <conio.h>
+#include <thread>
+
+#include "include/serial/SerialPort.hpp"
+#include "include/json.hpp"
+#include "chordNote.h"
+#include "song.h"
+
+using json = nlohmann::json;
+using namespace std;
+
+/*------------------------------ Constantes ---------------------------------*/
+#define BAUD 115200 // Frequence de transmission serielle
+//#define BAUD 9600 // Frequence de transmission serielle
+#define MSG_MAX_SIZE 1024 // Longueur maximale d'un message
+
+//Already defined in ChordNote.h
+//#define FRET_1 = 0
+//#define FRET_2 = 1
+//#define FRET_3 = 2
+//#define FRET_4 = 3
+//#define FRET_5 = 4
+
+#define STRUM_UP 5
+#define STRUM_DN 6
+#define JOY_DIR 7
+#define ACCEL 8
+#define MUONS 9
+
+#define JOY_DIR_UP 3
+#define JOY_DIR_DN 4
+
+
+
+/*------------------------- Prototypes de fonctions -------------------------*/
+bool SendToSerial(SerialPort* arduino, json j_msg);
+bool RcvFromSerial(SerialPort* arduino, string& msg);
+void RcvJsonThread();
+bool ComparePlayedNotes(ChordNote note, bool strumNeeded);
+bool CompareIndividualButton(bool wantedValue, int buttonState);
+bool CompareStrums();
+int GetLedState();
+int displayMenu();
+bool MenuInitialisation(int& numeroChanson, int& niveauDifficulte, vector<Song> repo);
+string printSelectionCursor(int selected, int lineIndex);
+void printEndOfSongScreen(int difficulty, Song song, int maxStreak, int points, int nbNotesReussies, int nbNotesSong);
+
+
+/*---------------------------- Variables globales ---------------------------*/
+SerialPort* arduino; //doit etre un objet global!
+int LedState = 0;
+int Fret1 = 0;
+int Fret2 = 0;
+int Fret3 = 0;
+int Fret4 = 0;
+int Fret5 = 0;
+int JoyDir = 0;
+int StrumUp = 0;
+int StrumDown = 0;
+int IsShaking = 0;
+int NotesCorrectStreak = 0;
+bool BargraphNeedReset = false;
+bool IsInPowerup = false;
+bool IsInDivineIntervention = false;
+int consecutiveStrumUP = 0;
+int consecutiveStrumDN = 0;
+
+bool isThreadOver = false;
+int StreakWhenLastSend = 0;
+bool isSameStrumUP = true;
+bool isSameStrumDN = true;
+int lastReceivedJoyDir = 0;
+int lastReceivedFret1 = 0;
+int lastReceivedFret2 = 0;
+bool isSameEvaluatedJoyDir = false;
+bool isSameEvaluatedFret1 = false;
+bool isSameEvaluatedFret2 = false;
+bool isInMenu = false;
+
+int MuonsCount = 0;
+
+int NB_NOTES_TO_INCREASE_POWERUP = 1;
+
+
+int main()
+{
+ vector<Song> repertoire; //Liste des chansons disponibles:
+ vector<string> songFolders; //Liste des dossiers chansons disponibles:
+ songFolders.push_back("\\Maynard-Ferguson-Birdland\\");
+ songFolders.push_back("\\Greta-Van-Fleet-Highway-Tune\\");
+ songFolders.push_back("\\Joan-Jett-and-the-Blackhearts-I-Love-Rock-_N-Roll-(The-Arrows-Cover)\\");
+ /*songFolders.push_back("\\Santana-Oye-Como-Va-(Tito-Puente-Cover)\\");
+ songFolders.push_back("\\Symphony-X-Eve-of-Seduction\\");
+ songFolders.push_back("\\Maynard-Ferguson-Country-Road-(James-Taylor-Cover)\\");
+ songFolders.push_back("\\Maynard-Ferguson-Theme-From-Shaft\\");
+ songFolders.push_back("\\Owane-Rock-Is-Too-Heavy\\");
+ songFolders.push_back("\\Stevie-Wonder-Contusion\\");
+ songFolders.push_back("\\Victor-Wooten-and-Steve-Bailey-A-Chick-from-Corea-(Live)\\");*/
+
+ string songRoot = "..\\songs";
+ string chartFile = "notes.chart";
+ for (int i = 0; i < songFolders.size(); i++)
+ {
+ repertoire.push_back(Song(songRoot + songFolders[i] + chartFile));
+ }
+ cout << "Chargement des chansons" << endl;
+ // Parse all the songs
+ for (int difficulty = 0; difficulty < 4; difficulty++)
+ {
+ for (int i = 0; i < repertoire.size(); i++)
+ {
+ if (difficulty == 3 && i == 2)
+ {
+ int bleh = 2;
+ }
+ repertoire[i].parseSync();
+ repertoire[i].parseChords(difficulty);
+ repertoire[i].consolidateChords(difficulty);
+ repertoire[i].trim(difficulty);
+ //cout << repertoire[i].getTitle() << " parsed!" << endl;
+ }
+ }
+
+ string com = "com7";
+ arduino = new SerialPort(com.c_str(), BAUD);
+
+ std::thread worker(RcvJsonThread);
+
+ if (!arduino->isConnected()) {
+ cerr << "Impossible de se connecter au port " << string(com.c_str()) << ". Fermeture du programme!" << endl;
+ exit(1);
+ }
+
+ int songIndex;
+ int difficulty;
+ while (MenuInitialisation(songIndex, difficulty, repertoire))
+ {
+ isInMenu = false;
+ std::vector<ChordNote> song;
+ switch (difficulty)
+ {
+ case (DIFFICULTY_EASY):
+ song = repertoire[songIndex].easy;
+ break;
+ case (DIFFICULTY_MEDIUM):
+ song = repertoire[songIndex].medium;
+ break;
+ case (DIFFICULTY_HARD):
+ song = repertoire[songIndex].hard;
+ break;
+ case (DIFFICULTY_EXPERT):
+ song = repertoire[songIndex].expert;
+ break;
+ default:
+ std::cerr << "Invalid difficulty" << std::endl;
+ return 1;
+ }
+
+
+ string displayString;
+
+ const int NB_SQUARES = 50;
+ const int FRAMERATE = 50;
+ int renderStart = FRAMERATE * (NB_SQUARES);
+
+ for (int i = 0; i < song.size(); i++)
+ {
+ song[i].setRenderStart(renderStart);
+ }
+
+ string displayArray[NB_SQUARES + 1][5];
+ for (int i = 0; i < NB_SQUARES + 1; i++)
+ {
+ for (int j = 0; j < 5; j++)
+ {
+ displayArray[i][j] = " ";
+ }
+ }
+
+ // TODO: Check if this command works as intended:
+ /* PlaySound(TEXT(song.getAudioFile().c_str()), NULL, SND_ASYNC); */
+
+ auto startTime = chrono::steady_clock::now();
+
+ double totalDiff = 0;
+ auto lastPrintTime = chrono::steady_clock::now();;
+ bool SongNotDone = true;
+
+ int nextRenderNoteIndex = 0;
+ int nextNoteToPlay = 0;
+ int points = 0;
+ bool hasLetGoHold = false;
+ int lastCorrectHoldTime = 0;
+ bool isPreviousNoteReussie = false;
+
+ int powerupStartTime = 0;
+ const int POWERUP_LENGTH = 15000;
+ int divineInterventionStartTime = 0;
+ const int DIVINE_INTERVENTION_LENGTH = 15000;
+ int lastDivineInterventionChecktime = 0;
+ const int DIVINE_INTERVENTION_CHECK_INTERVALL = 10000;
+ const int DIVINE_INVERVENTION_ODDS = 5; //1 out of x (10)
+ int powerupModifier = 1;
+
+ int NbNotesReussies = 0;
+ int MaxStreak = 0;
+
+ int endOfSong = song[song.size() - 1].getEnd();
+ if (endOfSong == 0)
+ {
+ endOfSong = song[song.size() - 1].getStart();
+ }
+ endOfSong += 500;
+
+ MuonsCount = 0;
+ while (SongNotDone)
+ {
+ auto currentTime = chrono::steady_clock::now();
+ totalDiff = int(std::chrono::duration_cast <std::chrono::milliseconds>(currentTime - startTime).count());
+
+ if (totalDiff > endOfSong)//End of song
+ //if (nextNoteToPlay == song.size())
+ {
+ /*isThreadOver = true;
+ worker.join();*/
+ MaxStreak = max(MaxStreak, NotesCorrectStreak);
+ printEndOfSongScreen(difficulty, repertoire[songIndex], MaxStreak, points, NbNotesReussies, song.size());
+ SongNotDone = false;
+ }
+ else
+ {
+ auto newCheckTime = chrono::steady_clock::now();
+
+ int diffSinceBeginning = int(std::chrono::duration_cast <std::chrono::milliseconds>(newCheckTime - startTime).count());
+
+ //CHECK NOTES INPUT
+ if (nextNoteToPlay < song.size())
+ {
+ int nextNoteStart = song[nextNoteToPlay].getStart();
+
+ if (abs(nextNoteStart - diffSinceBeginning) < 25 && nextNoteToPlay < song.size())
+ {
+ bool isNotePlayedCorrectly = ComparePlayedNotes(song[nextNoteToPlay], true); //TODO. DEVRA ETRE A TRUE
+ if (isNotePlayedCorrectly)
+ {
+ bool isStrummed = CompareStrums();
+ if (isStrummed)
+ {
+ NbNotesReussies++;
+ bool* notes = song[nextNoteToPlay].getNotes();
+ for (int i = 0; i < 5; i++)
+ {
+ if (notes[i])
+ {
+ points += 100 * powerupModifier;
+ }
+ }
+ nextNoteToPlay++;
+ NotesCorrectStreak++;
+ isPreviousNoteReussie = true;
+ lastCorrectHoldTime = diffSinceBeginning;
+ hasLetGoHold = false;
+ }
+ }
+ }
+ else
+ {
+ bool isStrumming = CompareStrums();
+ if (isStrumming)
+ {
+ MaxStreak = max(MaxStreak, NotesCorrectStreak);
+ NotesCorrectStreak = 0;
+ StreakWhenLastSend = 0;
+ points -= 10;
+ }
+ if (nextNoteStart < diffSinceBeginning && nextNoteToPlay < song.size())
+ {
+ nextNoteToPlay++;
+ MaxStreak = max(MaxStreak, NotesCorrectStreak);
+ NotesCorrectStreak = 0;
+ StreakWhenLastSend = 0;
+ isPreviousNoteReussie = false;
+ }
+ }
+ }
+
+ //Gestion des longues notes
+ int previousNoteEnd = 0;
+ if (nextNoteToPlay > 0)
+ {
+ previousNoteEnd = song[nextNoteToPlay - 1].getEnd();
+ }
+ if (previousNoteEnd > 0 && previousNoteEnd > diffSinceBeginning)
+ {
+ if (!hasLetGoHold && isPreviousNoteReussie)
+ {
+ bool isHeldNotePlayedCorrectly = ComparePlayedNotes(song[nextNoteToPlay - 1], false);
+ if (isHeldNotePlayedCorrectly)
+ {
+ if (lastCorrectHoldTime >= song[nextNoteToPlay - 1].getStart())
+ {
+ bool* notes = song[nextNoteToPlay - 1].getNotes();
+ int nbHeldNotes = 0;
+ for (int i = 0; i < 5; i++)
+ {
+ if (notes[i])
+ {
+ nbHeldNotes++;
+ }
+ }
+ points += ((diffSinceBeginning - lastCorrectHoldTime) * nbHeldNotes) * powerupModifier;
+ }
+ lastCorrectHoldTime = diffSinceBeginning;
+ }
+ else
+ {
+ hasLetGoHold = true;
+ }
+ }
+ }
+
+ //PowerUP and DivineIntervention
+ if (!IsInPowerup && IsShaking && LedState == 10)
+ {
+ IsInPowerup = true;
+ powerupStartTime = diffSinceBeginning;
+ powerupModifier *= 2;
+ }
+ if (IsInPowerup && diffSinceBeginning - powerupStartTime > POWERUP_LENGTH)
+ {
+ IsInPowerup = false;
+ BargraphNeedReset = true;
+ powerupModifier /= 2;
+ }
+ if (!IsInDivineIntervention && diffSinceBeginning - lastDivineInterventionChecktime > DIVINE_INTERVENTION_CHECK_INTERVALL)
+ {
+ lastDivineInterventionChecktime = diffSinceBeginning;
+ if (MuonsCount % DIVINE_INVERVENTION_ODDS == 0)
+ {
+ IsInDivineIntervention = true;
+ divineInterventionStartTime = diffSinceBeginning;
+ powerupModifier *= 2;
+ }
+ }
+ if (IsInDivineIntervention && diffSinceBeginning - divineInterventionStartTime > DIVINE_INTERVENTION_LENGTH)
+ {
+ IsInDivineIntervention = false;
+ powerupModifier /= 2;
+ lastDivineInterventionChecktime = diffSinceBeginning;
+ }
+
+ //Gestion affichage
+ if (diffSinceBeginning % FRAMERATE == 0)
+ {
+ //system("cls");
+ displayString.clear();
+ lastPrintTime = newCheckTime;
+ if (nextRenderNoteIndex > 0)
+ {
+ int previousNoteRenderStart = song[nextRenderNoteIndex - 1].getRenderStart();
+ int previousNoteEnd = song[nextRenderNoteIndex - 1].getEnd();
+ int previousNoteLength;
+ if (previousNoteEnd == 0)
+ {
+ previousNoteLength = 0;
+ }
+ else
+ {
+ previousNoteLength = previousNoteEnd - song[nextRenderNoteIndex - 1].getStart();
+ }
+ if ((diffSinceBeginning - previousNoteRenderStart) < previousNoteLength)
+ {
+ bool* notes = song[nextRenderNoteIndex - 1].getNotes();
+ for (int j = 0; j < 5; j++)
+ {
+ if (notes[j])
+ {
+ displayArray[0][j] = "|";
+ }
+ }
+ }
+ }
+
+ if (nextRenderNoteIndex < song.size())
+ {
+ if (abs(song[nextRenderNoteIndex].getRenderStart() - diffSinceBeginning) < 25)
+ {
+ bool* notes = song[nextRenderNoteIndex].getNotes();
+ for (int j = 0; j < 5; j++)
+ {
+ if (notes[j])
+ {
+ displayArray[0][j] = "X";
+ }
+ }
+ nextRenderNoteIndex++;
+ }
+ else if (song[nextRenderNoteIndex].getRenderStart() < diffSinceBeginning && nextRenderNoteIndex < song.size())
+ {
+ nextRenderNoteIndex++;
+ }
+ }
+
+ //printing
+ for (int i = 0; i < NB_SQUARES + 1; i++)
+ {
+ for (int j = 0; j < 5; j++)
+ {
+ if (i == NB_SQUARES - 1)
+ {
+ displayString += "|_" + displayArray[i][j] + "_";
+ }
+ else
+ {
+ displayString += "| " + displayArray[i][j] + " ";
+ }
+ }
+ displayString += "|\n";
+ }
+
+
+ //Reordering
+ int reorderingIndex = NB_SQUARES;
+ while (reorderingIndex > 0)
+ {
+ string temp[5];
+ for (int i = 0; i < 5; i++)
+ {
+ temp[i] = displayArray[reorderingIndex - 1][i];
+ }
+ for (int i = 0; i < 5; i++)
+ {
+ displayArray[reorderingIndex][i] = temp[i];
+ }
+ reorderingIndex--;
+ }
+ displayArray[0][0] = " ";
+ displayArray[0][1] = " ";
+ displayArray[0][2] = " ";
+ displayArray[0][3] = " ";
+ displayArray[0][4] = " ";
+
+ displayString += "\n";
+ string timestampString = to_string(diffSinceBeginning);
+ string ledStateString = to_string(LedState);
+ string streakString = to_string(NotesCorrectStreak);
+ string pointsString = to_string(points);
+ string powerupModifierString = to_string(powerupModifier);
+ string muonsCountString = to_string(MuonsCount);
+ string divineString = to_string(IsInDivineIntervention);
+ displayString += "Timestamp " + timestampString.substr(0, timestampString.find(".")) + " ms\n";
+ displayString += "Nb LEDs : " + ledStateString.substr(0, ledStateString.find(".")) + "/10\n";
+ displayString += "Nb notes de suite : " + streakString.substr(0, streakString.find(".")) + "\n";
+ displayString += "Points : " + pointsString.substr(0, pointsString.find(".")) + "\n";
+ displayString += "Muons : " + muonsCountString.substr(0, muonsCountString.find(".")) + " --- DIVINE : " + divineString.substr(0, divineString.find(".")) + "\n";
+
+ if (IsInPowerup)
+ {
+ if (IsInDivineIntervention)
+ {
+ displayString += "Multiplicateur : x" + powerupModifierString.substr(0, powerupModifierString.find(".")) + " --- POWERUP AND DIVINE INTERVENTION!!!!!\n";
+ }
+ displayString += "Multiplicateur : x" + powerupModifierString.substr(0, powerupModifierString.find(".")) + " --- POWERUP !!!!!\n";
+ }
+ else
+ {
+ if (IsInDivineIntervention)
+ {
+ displayString += "Multiplicateur : x" + powerupModifierString.substr(0, powerupModifierString.find(".")) + " --- DIVINE INTERVENTION!!!!!\n";
+ }
+ displayString += "Multiplicateur : x" + powerupModifierString.substr(0, powerupModifierString.find(".")) + "\n";
+ }
+
+ //string IsShakingString = to_string(IsShaking);
+ //displayString += "IsShaking : " + IsShakingString.substr(0, IsShakingString.find(".")) + "\n";
+
+ cout << displayString;
+ }
+ }
+ }
+ }
+ isThreadOver = true;
+ worker.join();
+
+ Sleep(2500);
+
+ return 0;
+}
+
+/*---------------------------Definition de fonctions ------------------------*/
+bool SendToSerial(SerialPort* arduino, json j_msg) {
+ // Return 0 if error
+ string msg = j_msg.dump();
+ bool ret = arduino->writeSerialPort(msg.c_str(), msg.length());
+ return ret;
+}
+
+
+bool RcvFromSerial(SerialPort* arduino, string& msg) {
+ // Return 0 if error
+ // Message output in msg
+ string str_buffer;
+ char char_buffer[MSG_MAX_SIZE];
+ int buffer_size;
+
+ msg.clear(); // clear string
+ // Read serialport until '\n' character (Blocking)
+
+ // Version fonctionnel dans VScode, mais non fonctionnel avec Visual Studio
+/*
+ while(msg.back()!='\n'){
+ if(msg.size()>MSG_MAX_SIZE){
+ return false;
+ }
+
+ buffer_size = arduino->readSerialPort(char_buffer, MSG_MAX_SIZE);
+ str_buffer.assign(char_buffer, buffer_size);
+ msg.append(str_buffer);
+ }
+*/
+
+// Version fonctionnelle dans VScode et Visual Studio
+ buffer_size = arduino->readSerialPort(char_buffer, MSG_MAX_SIZE);
+ str_buffer.assign(char_buffer, buffer_size);
+ msg.append(str_buffer);
+
+ //msg.pop_back(); //remove '/n' from string
+
+ return true;
+}
+
+void RcvJsonThread()
+{
+ string raw_msg;
+ json json_recu;
+ json json_envoye;
+ while (!isThreadOver)
+ {
+ //Envoie message Arduino
+ json_envoye["led"] = GetLedState();
+ if (!SendToSerial(arduino, json_envoye)) {
+ cerr << "Erreur lors de l'envoie du message. " << endl;
+ }
+ // Reception message Arduino
+ json_recu.clear(); // effacer le message precedent
+ if (!RcvFromSerial(arduino, raw_msg)) {
+ cerr << "Erreur lors de la reception du message. " << endl;
+ }
+ //cout << "Message : " << raw_msg << endl;
+
+ // Impression du message de l'Arduino si valide
+ if (raw_msg.size() > 0) {
+ //cout << "raw_msg: " << raw_msg << endl; // debug
+ // Transfert du message en json
+ json_recu = json::parse(raw_msg);
+ //out << "Message de l'Arduino: " << json_recu << endl;
+ }
+ if (json_recu == json::value_t::null)
+ {
+ //cout << "DATA_NULL\n";
+ }
+ else
+ {
+ //cout << "longueur " << j_msg_rcv.size() <<"\n";
+ //cout << "7 " << j_msg_rcv[7] <<"\n";
+ int tempFret1 = json_recu[FRET1];
+ if (isInMenu)
+ {
+ if (tempFret1 == lastReceivedFret1)
+ {
+ Fret1 = 0;
+ }
+ else
+ {
+ Fret1 = tempFret1;
+ isSameEvaluatedFret1 = false;
+ }
+ lastReceivedFret1 = tempFret1;
+ isSameEvaluatedFret1 = false;
+ }
+ else {
+ Fret1 = tempFret1;
+ }
+
+ int tempFret2 = json_recu[FRET2];
+ if (isInMenu)
+ {
+ if (tempFret2 == lastReceivedFret2)
+ {
+ Fret2 = 0;
+ }
+ else
+ {
+ Fret2 = tempFret2;
+ isSameEvaluatedFret2 = false;
+ }
+ lastReceivedFret2 = tempFret1;
+ isSameEvaluatedFret2 = false;
+ }
+ else {
+ Fret2 = tempFret2;
+ }
+
+ Fret3 = json_recu[FRET3];
+ Fret4 = json_recu[FRET4];
+ Fret5 = json_recu[FRET5];
+ /*StrumUp = json_recu[STRUM_UP];
+ StrumDown = json_recu[STRUM_DN];*/
+
+ int tempStrumUP = json_recu[STRUM_UP];
+ if (tempStrumUP == 1)
+ {
+ if (consecutiveStrumUP > 0)
+ {
+ StrumUp = 0;
+ }
+ else {
+ StrumUp = 1;
+ consecutiveStrumUP++;
+ isSameStrumUP = false;
+ }
+ }
+ else {
+ StrumUp = 0;
+ consecutiveStrumUP = 0;
+ }
+
+ int tempStrumDown = json_recu[STRUM_DN];
+ if (tempStrumDown == 1)
+ {
+ if (consecutiveStrumDN > 0)
+ {
+ StrumDown = 0;
+ }
+ else {
+ StrumDown = 1;
+ consecutiveStrumDN++;
+ isSameStrumDN = false;
+ }
+ }
+ else {
+ StrumDown = 0;
+ consecutiveStrumDN = 0;
+ }
+
+ int tempJoyDir = json_recu[JOY_DIR];
+ if (tempJoyDir == lastReceivedJoyDir)
+ {
+ JoyDir = 0;
+ }
+ else
+ {
+ JoyDir = tempJoyDir;
+ isSameEvaluatedJoyDir = false;
+ }
+ lastReceivedJoyDir = tempJoyDir;
+ IsShaking = json_recu[ACCEL];
+
+ MuonsCount += json_recu[MUONS];
+ //MuonsCount += rand() % 10 + 1;//rand() % range + min
+ /*if (IsShaking)
+ {
+ cout << "SENSIBILITE BEN TROP BASSE" << endl;
+ }*/
+ }
+ Sleep(1);
+ }
+}
+
+bool ComparePlayedNotes(ChordNote note, bool strumNeeded)
+{
+ bool correctlyPlayed = false;
+ bool* notes = note.getNotes();
+
+ bool comp1 = CompareIndividualButton(notes[0], Fret1);
+ bool comp2 = CompareIndividualButton(notes[1], Fret2);
+ bool comp3 = CompareIndividualButton(notes[2], Fret3);
+ bool comp4 = CompareIndividualButton(notes[3], Fret4);
+ bool comp5 = CompareIndividualButton(notes[4], Fret5);
+
+ if (comp1 && comp2 && comp3 && comp4 && comp5)
+ {
+ correctlyPlayed = true;
+ /*if (strumNeeded)
+ {
+ bool compDown = CompareIndividualButton(true, StrumDown);
+ if (isSameStrumDN && compDown)
+ {
+ compDown = false;
+ }
+ else {
+ isSameStrumDN = true;
+ }
+ bool compUp = CompareIndividualButton(true, StrumUp);
+ if (isSameStrumUP && compDown)
+ {
+ compUp = false;
+ }
+ else {
+ isSameStrumUP = true;
+ }
+
+ if (!compDown && !compUp)
+ {
+ correctlyPlayed = false;
+ }
+ }*/
+ }
+
+ return correctlyPlayed;
+}
+
+bool CompareStrums()
+{
+ bool correctlyPlayed = false;
+
+ bool compDn = StrumDown;
+ if (isSameStrumDN)
+ {
+ compDn = false;
+ }
+ else {
+ if (compDn)
+ {
+ isSameStrumDN = true;
+ }
+ }
+
+ bool compUp = StrumUp;
+ if (isSameStrumUP)
+ {
+ compUp = false;
+ }
+ else {
+ if (compUp)
+ {
+ isSameStrumUP = true;
+ }
+ }
+
+ if (compDn || compUp)
+ {
+ correctlyPlayed = true;
+ }
+ return correctlyPlayed;
+}
+
+bool CompareIndividualButton(bool wantedValue, int buttonState)
+{
+ return wantedValue == buttonState;
+}
+
+int GetLedState()
+{
+ if (IsInPowerup)
+ {
+ LedState++;
+ if (LedState > 10)
+ {
+ LedState = 0;
+ }
+ }
+ else
+ {
+ if (NotesCorrectStreak % NB_NOTES_TO_INCREASE_POWERUP == 0 && StreakWhenLastSend < NotesCorrectStreak)
+ {
+ LedState++;
+ StreakWhenLastSend = NotesCorrectStreak;
+ }
+ if (LedState > 10)
+ {
+ LedState = 10;
+ }
+ if (BargraphNeedReset)
+ {
+ LedState = 0;
+ BargraphNeedReset = false;
+ StreakWhenLastSend = 0;
+ }
+ }
+ return LedState;
+}
+
+bool MenuInitialisation(int& numeroChanson, int& niveauDifficulte, vector<Song> repo) {
+ //display du Menu
+ isInMenu = true;
+ int repo_size = repo.size();
+ int choix = 0;
+ bool madeADecision = false;
+ bool retour = false;
+ bool wantToReturn = false;
+ bool madeSongDecision = false;
+ bool madeDifficultyDecision = false;
+ int choixChanson = 1;
+ int choixDifficulte = 1;
+ bool inputSelected = false;
+
+ while (!madeADecision)
+ {
+ choix = displayMenu();
+ switch (choix)
+ {
+ case 1:
+ choixChanson = 1;
+ wantToReturn = false;
+ madeSongDecision = false;
+ while (!madeSongDecision)
+ {
+ //choisir chanson
+ system("CLS");
+ cout << "----------------------------------------------------------------------" << endl;
+ cout << "\t\t\tMENU CHOIX DE CHANSON" << endl;
+ cout << "----------------------------------------------------------------------\n" << endl;
+ //cout << " On devra faire un display des chansons disponibles...\n";
+ /*
+ for (int i = 0; i < repertoire.size; i++){
+ cout << i+1 << ". " << repertoire[i].song.getTitle() << endl;
+ }
+ */
+ for (int i = 0; i < repo_size + 1; i++) {
+ if (i == repo_size)
+ {
+ cout << i + 1 << ". Retour" << printSelectionCursor(choixChanson, i+1) << endl;
+ }
+ else {
+ cout << i + 1 << ". " << repo[i].getTitle() << " par " << repo[i].getArtist() << printSelectionCursor(choixChanson, i + 1) << endl;
+ }
+ }
+ cout << "\nChoisissez une chanson (Vert pour selectionner, Rouge pour revenir en arriere): ";
+ /*cin >> numeroChanson;
+ while (numeroChanson < 1 || numeroChanson > repo.size() + 1) {
+ cout << "Entree non valide. Veuillez entrer un numero de chanson valide" << endl;
+ cin >> numeroChanson;
+ }*/
+ inputSelected = false;
+ while (!inputSelected)
+ {
+ if (JoyDir == JOY_DIR_UP && !isSameEvaluatedJoyDir)
+ {
+ isSameEvaluatedJoyDir = true;
+ if (choixChanson > 1)
+ {
+ choixChanson--;
+ inputSelected = true;
+ }
+ }
+ if (JoyDir == JOY_DIR_DN && !isSameEvaluatedJoyDir)
+ {
+ isSameEvaluatedJoyDir = true;
+ if (choixChanson < repo_size + 1)
+ {
+ choixChanson++;
+ inputSelected = true;
+ }
+ }
+ if (Fret1 && !isSameEvaluatedFret1)
+ {
+ isSameEvaluatedFret1 = true;
+ inputSelected = true;
+ madeSongDecision = true;
+ }
+ if (Fret2 && !isSameEvaluatedFret2)
+ {
+ isSameEvaluatedFret2 = true;
+ inputSelected = true;
+ madeSongDecision = true;
+ wantToReturn = true;
+ }
+ }
+ if (choixChanson == repo_size + 1)
+ {
+ wantToReturn = true;
+ }
+ }
+ numeroChanson = choixChanson - 1;
+
+
+ if (!wantToReturn)
+ {
+ choixDifficulte = 1;
+ wantToReturn = false;
+ madeDifficultyDecision = false;
+ while (!madeDifficultyDecision)
+ {
+
+ //choisir niveau de difficult�
+ system("CLS");
+ cout << "----------------------------------------------------------------------" << endl;
+ cout << "\t\t\tMENU NIVEAU DE DIFFICULTE" << endl;
+ cout << "----------------------------------------------------------------------\n" << endl;
+
+ cout << "1. Easy" << printSelectionCursor(choixDifficulte, 1) << endl;
+ cout << "2. Medium" << printSelectionCursor(choixDifficulte, 2) << endl;
+ cout << "3. Hard" << printSelectionCursor(choixDifficulte, 3) << endl;
+ cout << "4. Expert" << printSelectionCursor(choixDifficulte, 4) << endl;
+ cout << "5. Retour" << printSelectionCursor(choixDifficulte, 5) << endl;
+
+ cout << "\nChoisissez le niveau de difficulte (Vert pour selectionner, Rouge pour revenir en arriere): ";
+ /*cin >> niveauDifficulte;
+ while (niveauDifficulte < 0 || niveauDifficulte > 5) {
+ cout << "Entree non valide. Veuillez entrer un niveau de difficulte valide" << endl;
+ cin >> niveauDifficulte;
+ }*/
+ inputSelected = false;
+ while (!inputSelected)
+ {
+ if (JoyDir == JOY_DIR_UP && !isSameEvaluatedJoyDir)
+ {
+ isSameEvaluatedJoyDir = true;
+ if (choixDifficulte > 1)
+ {
+ choixDifficulte--;
+ inputSelected = true;
+ }
+ }
+ if (JoyDir == JOY_DIR_DN && !isSameEvaluatedJoyDir)
+ {
+ isSameEvaluatedJoyDir = true;
+ if (choixDifficulte < 5)
+ {
+ choixDifficulte++;
+ inputSelected = true;
+ }
+ }
+ if (Fret1 && !isSameEvaluatedFret1)
+ {
+ isSameEvaluatedFret1 = true;
+ inputSelected = true;
+ madeDifficultyDecision = true;
+ }
+ if (Fret2 && !isSameEvaluatedFret2)
+ {
+ isSameEvaluatedFret2 = true;
+ inputSelected = true;
+ madeDifficultyDecision = true;
+ wantToReturn = true;
+ }
+ }
+ if (choixDifficulte == 5)
+ {
+ wantToReturn = true;
+ }
+ niveauDifficulte = choixDifficulte - 1;
+
+ //case 3:
+ // system("CLS");
+ // cout << "Le jeu va debuter...!!\n" << endl;
+ // if (*numeroChanson < 1 || *numeroChanson > 4 || *niveauDifficulte < 1 || *niveauDifficulte > 4) {
+ // //chanson et difficulte par defaut
+ // *numeroChanson = 1;
+ // *niveauDifficulte = 1;
+ // }
+ // cout << "Chanson choisie : " << listeChansons[*numeroChanson - 1] << endl;
+ // cout << "Niveau de difficulte : " << listeDifficultes[*niveauDifficulte - 1] << "\n\n";
+ // return true; //debuter le jeu
+ // break;
+ }
+ }
+
+ if (!wantToReturn)
+ {
+ madeADecision = true;
+ retour = true;
+ }
+
+ break;
+ case 2:
+ system("CLS");
+ cout << "FLAMMING DEVELISH RELISH" << endl;
+ cout << "Projet de session S2-H23 de l'equipe P-05" << endl;
+ cout << "Benjamin Chaussé" << endl;
+ cout << "Simon Gagné" << endl;
+ cout << "Brenda Keimgou Tchio" << endl;
+ cout << "Guillaume Malgorn" << endl;
+ cout << "Gabriel Nadeau" << endl;
+ cout << "Zachary Poulin" << endl;
+
+ cout << "Appuyez sur Vert ou Rouge pour continuer" << endl;
+ inputSelected = false;
+ while (!inputSelected)
+ {
+ if (Fret1 && !isSameEvaluatedFret1)
+ {
+ isSameEvaluatedFret1 = true;
+ inputSelected = true;
+ }
+ if (Fret2 && !isSameEvaluatedFret2)
+ {
+ isSameEvaluatedFret2 = true;
+ inputSelected = true;
+ }
+ }
+ break;
+
+ case 3:
+ system("CLS");
+ cout << "A bientot, KEEP ON ROCKING!!" << endl;
+ madeADecision = true;
+ retour = false; //quitter le jeu
+ break;
+
+ default:
+ break;
+ }
+ }
+ return retour;
+}
+
+//Fonction qui presente la premiere section du menu
+int displayMenu() {
+ bool madeAChoice = false;
+ int choix = 1;
+ while (!madeAChoice)
+ {
+ system("CLS");
+ cout << "----------------------------------------------------------------------" << endl;
+ cout << "\t\tMENU GUITAR HERO DEVELISH RELLISH" << endl;
+ cout << "----------------------------------------------------------------------\n" << endl;
+ cout << " 1. Debuter le jeu " << printSelectionCursor(choix, 1) << endl;
+ cout << " 2. Informations " << printSelectionCursor(choix, 2) << endl;
+ cout << " 3. Quitter le jeu" << printSelectionCursor(choix, 3) << endl;
+ cout << "\nChoisissez une option (Vert pour selectionner): ";
+ //cin >> choix;
+ /*while (choix < 1 || choix > 3) {
+ cout << "Choix non valide. Veuillez choisir une option valide" << endl;
+ cin >> choix;
+ }*/
+
+ bool inputSelected = false;
+ while (!inputSelected)
+ {
+ if (JoyDir == JOY_DIR_UP && !isSameEvaluatedJoyDir)
+ {
+ isSameEvaluatedJoyDir = true;
+ if (choix > 1)
+ {
+ choix--;
+ inputSelected = true;
+ }
+ }
+ if (JoyDir == JOY_DIR_DN && !isSameEvaluatedJoyDir)
+ {
+ isSameEvaluatedJoyDir = true;
+ if (choix < 3)
+ {
+ choix++;
+ inputSelected = true;
+ }
+ }
+ if (Fret1 && !isSameEvaluatedFret1)
+ {
+ isSameEvaluatedFret1 = true;
+ inputSelected = true;
+ madeAChoice = true;
+ }
+ }
+ }
+
+ return choix;
+}
+
+string printSelectionCursor(int selected, int lineIndex)
+{
+ if (selected == lineIndex)
+ {
+ return " <---";
+ }
+ else {
+ return "";
+ }
+}
+
+void printEndOfSongScreen(int difficulty, Song song, int maxStreak, int points, int nbNotesReussies, int nbNotesSong)
+{
+ LedState = 0;
+ system("CLS");
+ cout << song.getTitle() << " par " << song.getArtist() << endl;
+ cout << "Difficulte : ";
+ switch (difficulty)
+ {
+ case DIFFICULTY_EASY:
+ cout << "Easy" << endl;
+ break;
+ case DIFFICULTY_MEDIUM:
+ cout << "Medium" << endl;
+ break;
+ case DIFFICULTY_HARD:
+ cout << "Hard" << endl;
+ break;
+ case DIFFICULTY_EXPERT:
+ cout << "Expert" << endl;
+ break;
+ }
+ cout << nbNotesReussies * 100 / nbNotesSong << "%" << endl;
+ cout << points << " points" << endl;
+ cout << nbNotesReussies << " notes reussies" << endl;
+ cout << "Plus haute sequence de suite :" << maxStreak << endl;
+
+ cout << "\nAppuyer sur Vert pour continuer";
+
+ isInMenu = true;
+ bool inputSelected = false;
+ while (!inputSelected)
+ {
+ if (Fret1 && !isSameEvaluatedFret1)
+ {
+ isSameEvaluatedFret1 = true;
+ inputSelected = true;
+ }
+ }
+}
\ No newline at end of file |