summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rwxr-xr-xdisplay.cpp55
-rwxr-xr-xdisplay.h34
-rwxr-xr-xgame.cpp199
-rwxr-xr-xloadSongs.cpp367
-rwxr-xr-xmain.cpp126
-rwxr-xr-xmain_old.cpp200
-rwxr-xr-xmenu.cpp65
7 files changed, 1046 insertions, 0 deletions
diff --git a/display.cpp b/display.cpp
new file mode 100755
index 0000000..6422030
--- /dev/null
+++ b/display.cpp
@@ -0,0 +1,55 @@
+#include "logging.h"
+#include "display.h"
+
+display screen;
+
+/**
+* Loads a BMP image into a texture on the rendering device
+* @param file The BMP image file to load
+* @param ren The renderer to load the texture onto
+* @return the loaded texture, or nullptr if something went wrong.
+*/
+SDL_Texture* loadTexture(const std::string &file, SDL_Renderer *ren){
+ SDL_Log("loadTexture %s", file.c_str());
+ //Initialize to nullptr to avoid dangling pointer issues
+ SDL_Texture *texture = nullptr;
+ //Load the image
+ SDL_Surface *loadedImage = IMG_Load(file.c_str());
+ //If the loading went ok, convert to texture and return the texture
+ if (loadedImage != nullptr){
+ texture = SDL_CreateTextureFromSurface(ren, loadedImage);
+ SDL_FreeSurface(loadedImage);
+ //Make sure converting went ok too
+ if (texture == nullptr)
+ logSDLError("CreateTextureFromSurface");
+ }
+ else
+ logSDLError("IMG_Load");
+
+ return texture;
+}
+
+/**
+* Draw an SDL_Texture to an SDL_Renderer at position x, y, preserving
+* the texture's width and height
+* @param tex The source texture we want to draw
+* @param ren The renderer we want to draw too
+* @param x The x coordinate to draw too
+* @param y The y coordinate to draw too
+* @param angle The angle of rotation
+*/
+void renderTexture(SDL_Texture *tex, SDL_Renderer *ren, float x, float y, double angle){
+ //Setup the destination rectangle to be at the position we want
+ SDL_Rect dst;
+ dst.x = x*screen.width;
+ dst.y = y*screen.height;
+ //Query the texture to get its width and height to use
+ SDL_QueryTexture(tex, NULL, NULL, &dst.w, &dst.h);
+ SDL_RenderCopyEx(ren, tex, NULL, &dst, angle, NULL, SDL_FLIP_NONE);
+}
+
+void renderTexture(SDL_Texture *tex, SDL_Renderer *ren, float x, float y){
+ renderTexture(tex, ren, x, y, 0);
+}
+
+
diff --git a/display.h b/display.h
new file mode 100755
index 0000000..9609140
--- /dev/null
+++ b/display.h
@@ -0,0 +1,34 @@
+#ifndef DISPLAY_H_INCLUDED
+#define DISPLAY_H_INCLUDED
+
+#include <string>
+#include <SDL.h>
+#include <SDL_image.h>
+#include <SDL_ttf.h>
+
+#define STATE_INIT 0
+#define STATE_MENU 1
+#define STATE_PLAYING 2
+
+
+SDL_Texture* loadTexture(const std::string &file, SDL_Renderer *ren);
+void renderTexture(SDL_Texture *tex, SDL_Renderer *ren, float x, float y);
+
+struct display
+{
+ int height;
+ int width;
+ const char * name;
+ SDL_Renderer *renderer;
+ SDL_Window *window;
+ TTF_Font *font;
+
+ int state;
+
+ display(): width(600), height(600), name("MaiMai"), state(STATE_INIT) {}
+
+};
+
+extern display screen;
+
+#endif // DISPLAY_H_INCLUDED
diff --git a/game.cpp b/game.cpp
new file mode 100755
index 0000000..5090746
--- /dev/null
+++ b/game.cpp
@@ -0,0 +1,199 @@
+#include "display.h"
+#include "music.h"
+
+std::vector<displaynote> load_notes()
+{
+ int difficulty = 0;
+ int current_note = 0;
+ int current_line = 0;
+ int current_mes = 0;
+
+ std::vector<displaynote> displayednotes;
+ int ms=0;
+ while(current_mes<=songData->songNotes[difficulty].noteData.size())
+ {
+ std::vector<Note> note = songData->songNotes[difficulty].noteData[current_mes][current_line];
+
+ float time = 1000.0f/(songData->bpms[0].bpm/60.0f);
+
+ if(songData->songNotes[difficulty].noteData[current_mes].size() != 4)
+ time = time/((float)songData->songNotes[difficulty].noteData[current_mes].size()/4.0f);
+
+ for(std::vector<displaynote>::iterator current_note = note.begin(); show_note != note.end(); ++current_note) {
+ if(note[0] == Tap)
+ {
+ currentNote.orientation = "left";
+ displayednotes[ms]=currentNote;
+ }
+ if(note[1] == Tap)
+ {
+ currentNote.orientation = "up";
+ displayednotes[ms]=currentNote;
+ }
+ if(note[2] == Tap)
+ {
+ currentNote.orientation = "down";
+ displayednotes[ms]=currentNote;
+ }
+ if(note[3] == Tap)
+ {
+ currentNote.orientation = "right";
+ currentNote.x = 0.5f - (float)rightW / (float)(SCREEN_WIDTH*2);
+ currentNote.y = 0.5f - (float)rightH / (float)(SCREEN_HEIGHT*2);
+ displayednotes[ms]=currentNote;
+ }
+ }
+ current_line += 1;
+
+ if(songData->songNotes[difficulty].noteData[current_mes].size() <= current_line)
+ {
+ current_line = 0;
+ current_mes +=1;
+ }
+ ms+=time;
+ }
+ return displayednotes;
+}
+
+int init_game()
+{
+ unsigned int last_tick = SDL_GetTicks();
+ unsigned int last_update = 0;
+ std::vector<displaynote> displayednotes = load_notes();
+ displaynote currentNote;
+
+ SDL_Texture *arrow;
+
+ musique = Mix_LoadMUS(path.c_str());
+ if(musique == nullptr)
+ logMixError(std::cout, "LoadMUS");
+
+ arrow = loadTexture("/sdcard/up_arrow.png", screen.renderer);
+
+ int arrowW, arrowH;
+ SDL_QueryTexture(arrow, NULL, NULL, &arrowW, &arrowH);
+
+ unsigned int first_tick = SDL_GetTicks();
+ float song_offset = (((0.4f/speed)*20.0f)+songData->offset*1000.0f);
+ SDL_Log("offset: %f", song_offset);
+}
+
+int update_game()
+{
+
+ if(((SDL_GetTicks() - first_tick) >= (int)song_offset) && !playing)
+ {
+ if((musique != nullptr) && (Mix_PlayMusic(musique, 0) == -1))
+ {
+ logMixError(std::cout, "PlayMusic");
+ quit = true;
+ }
+ else
+ {
+ first_tick = SDL_GetTicks();
+ playing = true;
+ }
+ }
+
+ if(SDL_GetTicks() - last_update >= 20)
+ {
+ last_update = SDL_GetTicks();
+ SDL_RenderPresent(renderer);
+
+ SDL_RenderClear(renderer);
+ renderTexture(background, renderer, 0.0f, 0.0f);
+ renderTexture(background, renderer, bW, 0.0f);
+ renderTexture(background, renderer, 0.0f, bH);
+ renderTexture(background, renderer, bW, bH);
+
+ SDL_SetTextureColorMod(left, 0, 0, 255);
+ SDL_SetTextureColorMod(up, 0, 0, 255);
+ SDL_SetTextureColorMod(down, 0, 0, 255);
+ SDL_SetTextureColorMod(right, 0, 0, 255);
+
+ renderTexture(left, renderer, 0.1f - (float)leftW / (float)(SCREEN_WIDTH*2), 0.5f - (float)leftH / (float)(SCREEN_HEIGHT*2));
+ renderTexture(up, renderer, 0.5f - (float)upW / (float)(SCREEN_WIDTH*2), 0.9f - (float)upH / (float)(SCREEN_HEIGHT*2));
+ renderTexture(down, renderer, 0.5f - (float)downW / (float)(SCREEN_WIDTH*2), 0.1f - (float)downH / (float)(SCREEN_HEIGHT*2));
+ renderTexture(right, renderer, 0.9f - (float)rightW / (float)(SCREEN_WIDTH*2), 0.5f - (float)rightH / (float)(SCREEN_HEIGHT*2));
+
+ SDL_SetTextureColorMod(left, 255, 255, 255);
+ SDL_SetTextureColorMod(up, 255, 255, 255);
+ SDL_SetTextureColorMod(down, 255, 255, 255);
+ SDL_SetTextureColorMod(right, 255, 255, 255);
+
+ for(std::vector<displaynote>::iterator show_note = displayednotes.begin(); show_note != displayednotes.end(); ++show_note) {
+ bool deleted = false;
+ if(show_note->orientation != "center")
+ for(std::vector<SDL_TouchFingerEvent>::iterator touch = touchEvents.begin(); touch != touchEvents.end(); ++touch) {
+
+ if( ((show_note->orientation == "left") &&
+ (show_note->x >= 0.05f && show_note->x <= 0.15f && show_note->y == 0.5f - (float)leftH / (float)(SCREEN_HEIGHT*2)) &&
+ (touch->x >= 0.0f && touch->x <= 0.25f && touch->y >= 0.20f && touch->y <= 0.80f)) ||
+ ((show_note->orientation == "up") &&
+ (show_note->x == 0.5f - (float)upW / (float)(SCREEN_WIDTH*2) && show_note->y >= 0.05f && show_note->y <= 0.15f) &&
+ (touch->x >= 0.20f && touch->x <= 0.80f && touch->y >= 0.0f && touch->y <= 0.25f)) ||
+ ((show_note->orientation == "down") &&
+ (show_note->x == 0.5f - (float)downW / (float)(SCREEN_WIDTH*2) && show_note->y >= 0.85f && show_note->y <= 0.95f) &&
+ (touch->x >= 0.20f && touch->x <= 0.80f && touch->y >= 1.0f && touch->y <= 0.75f)) ||
+ ((show_note->orientation == "right") &&
+ (show_note->x >= 0.85f && show_note->x <= 0.95f && show_note->y == 0.5f - (float)rightH / (float)(SCREEN_HEIGHT*2)) &&
+ (touch->x >= 0.75f && touch->x <= 1.0f && touch->y >= 0.20f && touch->y <= 0.80f)))
+ {
+
+ currentNote.texture = image;
+ currentNote.orientation = "center";
+ currentNote.x = iW;
+ currentNote.y = iH;
+ displayednotes.push_back(currentNote);
+
+ SDL_SetTextureColorMod(show_note->texture, 255, 0, 0);
+ renderTexture(show_note->texture, renderer, show_note->x, show_note->y);
+ SDL_SetTextureColorMod(show_note->texture, 255, 255, 255);
+ touchEvents.erase(touch);
+ displayednotes.erase(show_note);
+ deleted = true;
+ break;
+ }
+ }
+
+ if(!deleted)
+ {
+ if(show_note->x <= 0.0f || show_note->y <= 0.0f)
+ {
+ displayednotes.erase(show_note);
+ continue;
+ }
+ renderTexture(show_note->texture, renderer, show_note->x, show_note->y);
+
+ if(show_note->orientation == "left")
+ show_note->x -= speed;
+ if(show_note->orientation == "up")
+ show_note->y -= speed;
+ if(show_note->orientation == "down")
+ show_note->y += speed;
+ if(show_note->orientation == "right")
+ show_note->x += speed;
+ if(show_note->orientation == "center")
+ {
+ show_note->y += speed;
+ show_note->x += speed;
+ }
+ }
+ }
+
+ touchEvents.clear();
+ }
+}
+
+int quit_game()
+{
+ SDL_DestroyTexture(background);
+ SDL_DestroyTexture(image);
+
+ SDL_Log("Music was playing");
+ Mix_HaltMusic();
+ SDL_Log("Music halted");
+ Mix_FreeMusic(musique);
+ musique = NULL;
+ SDL_Log("Music freed");
+}
diff --git a/loadSongs.cpp b/loadSongs.cpp
new file mode 100755
index 0000000..0948212
--- /dev/null
+++ b/loadSongs.cpp
@@ -0,0 +1,367 @@
+#include <dirent.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#include <sstream>
+#include <algorithm>
+#include <string>
+
+#include "logging.h"
+#include "files.h"
+
+const char *songsPath = "/sdcard/Songs/";
+
+void split(std::vector<std::string> &tokens, const std::string &text, const char *sep) {
+ int start = 0, end = 0;
+ while ((end = text.find(sep, start)) != std::string::npos) {
+ tokens.push_back(text.substr(start, end - start));
+ start = end + 1;
+ }
+ tokens.push_back(text.substr(start));
+}
+
+// trim from start
+static inline std::string &ltrim(std::string &s) {
+ s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(isspace))));
+ return s;
+}
+
+// trim from end
+static inline std::string &rtrim(std::string &s) {
+ s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(isspace))).base(), s.end());
+ return s;
+}
+
+// trim from both ends
+static inline std::string &trim(std::string &s) {
+ return ltrim(rtrim(s));
+}
+
+/* Returns a list of directories (except the ones that begin with a dot) */
+
+void GetDirectories(std::vector<std::string> &out, const char *directory)
+{
+#ifdef WINDOWS
+ HANDLE dir;
+ WIN32_FIND_DATA file_data;
+
+ if ((dir = FindFirstFile((directory + "/*").c_str(), &file_data)) == INVALID_HANDLE_VALUE)
+ return; /* No files found */
+
+ do {
+ const string file_name = file_data.cFileName;
+ const string full_file_name = directory + "/" + file_name;
+ const bool is_directory = (file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+
+ if (file_name[0] == '.')
+ continue;
+
+ if (!is_directory)
+ continue;
+
+ out.push_back(full_file_name);
+ } while (FindNextFile(dir, &file_data));
+
+ FindClose(dir);
+#else
+ DIR *dir;
+ class dirent *ent;
+ class stat st;
+
+ dir = opendir(directory);
+ if(dir == NULL)
+ {
+ std::string errmsg = "Cannot open directory ";
+ logstdError("GetDirectories", errmsg + directory);
+ }
+ else
+ {
+ while ((ent = readdir(dir)) != NULL) {
+ const std::string file_name = ent->d_name;
+ std::string full_file_name = directory;
+ full_file_name.append("/" + file_name + "/");
+
+ if (file_name[0] == '.')
+ continue;
+
+ if (stat(full_file_name.c_str(), &st) == -1)
+ continue;
+
+ if (!S_ISDIR(st.st_mode))
+ continue;
+
+ out.push_back(full_file_name);
+ }
+ closedir(dir);
+ if(out.empty())
+ {
+ std::string errmsg = "Directory empty: ";
+ logstdError("GetDirectories", errmsg + directory);
+ }
+ }
+#endif
+} // GetFilesInDirectory
+
+/* Returns a list of sm files */
+
+void GetSmFiles(std::vector<std::string> &out, const std::string directory)
+{
+#ifdef WINDOWS
+ HANDLE dir;
+ WIN32_FIND_DATA file_data;
+
+ if ((dir = FindFirstFile((directory + "/*").c_str(), &file_data)) == INVALID_HANDLE_VALUE)
+ return; /* No files found */
+
+ do {
+ const string file_name = file_data.cFileName;
+ const string full_file_name = directory + "/" + file_name;
+ const bool is_directory = (file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+
+ std::vector<std::string> tokens;
+ split(tokens, file_name, ".");
+
+ if (strcmp(tokens.back(), "sm"))
+ continue;
+
+ if (is_directory)
+ continue;
+
+ out.push_back(full_file_name);
+ } while (FindNextFile(dir, &file_data));
+
+ FindClose(dir);
+#else
+ DIR *dir;
+ class dirent *ent;
+ class stat st;
+
+ dir = opendir(directory.c_str());
+ if(dir == NULL)
+ {
+ std::string errmsg = "Cannot open directory ";
+ logstdError("GetDirectories", errmsg + directory);
+ }
+ else
+ {
+ while ((ent = readdir(dir)) != NULL) {
+ const std::string file_name = ent->d_name;
+ std::string full_file_name = directory;
+ full_file_name.append("/" + file_name);
+
+ std::vector<std::string> tokens;
+ split(tokens, file_name, ".");
+
+ if (tokens.back() != "sm")
+ continue;
+
+ if (stat(full_file_name.c_str(), &st) == -1)
+ continue;
+
+ const bool is_readable = (st.st_mode & S_IRUSR) != 0;
+
+ if (!is_readable)
+ continue;
+
+ out.push_back(file_name);
+ }
+ closedir(dir);
+ if(out.empty())
+ {
+ std::string errmsg = "Directory empty: ";
+ logstdError("GetDirectories", errmsg + directory);
+ }
+ }
+#endif
+} // GetSmFiles
+
+
+int readSongFile(std::string &path, musicfile &songFile)
+{
+ bool reading_note = false;
+ int current_note_line = 0;
+ std::vector<Note> currentNoteData;
+ std::vector<std::vector<Note>> currentLineNoteData;
+ notes currentNotes;
+
+ std::string line;
+ std::ifstream file;
+ file.open(path.c_str(), std::ifstream::in);
+ if (!file)
+ {
+ std::string msg = "Could not open ";
+ msg.append(path);
+ logstdError("loadFile", msg);
+ return 1;
+ }
+ while(file.good())
+ {
+ std::getline(file, line);
+ line = trim(line);
+ if(line.length() == 0)
+ continue;
+ else if(line[0] == '/')
+ continue;
+ else if(line[0] == '#')
+ {
+ std::vector<std::string> tokens;
+ split(tokens, line, ":");
+
+ if(tokens[0].compare("#NOTES") == 0)
+ {
+ reading_note = true;
+ continue;
+ }
+ else
+ reading_note = false;
+
+ if(*tokens[1].rbegin() == ';')
+ tokens[1].pop_back();
+
+ if(tokens[0].compare("#TITLE") == 0)
+ {
+ songFile.title = tokens[1];
+ }
+ else if(tokens[0].compare("#ARTIST") == 0)
+ {
+ songFile.artist = tokens[1];
+ }
+ else if(tokens[0].compare("#BANNER") == 0)
+ {
+ songFile.banner = tokens[1];
+ }
+ else if(tokens[0].compare("#BACKGROUND") == 0)
+ {
+ songFile.background = tokens[1];
+ }
+ else if(tokens[0].compare("#MUSIC") == 0)
+ {
+ songFile.file = tokens[1];
+ }
+ else if(tokens[0].compare("#OFFSET") == 0)
+ {
+ std::istringstream(tokens[1]) >> songFile.offset;
+ }
+ else if(tokens[0].compare("#BPMS") == 0)
+ {
+ std::vector<std::string> listBpms;
+ split(listBpms, tokens[1], ",");
+ for(std::vector<std::string>::iterator bpmData = listBpms.begin(); bpmData != listBpms.end(); ++bpmData)
+ {
+ std::vector<std::string> bpm;
+ split(bpm, *bpmData, "=");
+ songBpm bpms;
+ std::istringstream(bpm[0]) >> bpms.beat;
+ std::istringstream(bpm[1]) >> bpms.bpm;
+ songFile.bpms.push_back(bpms);
+ }
+ }
+ }
+ else if(reading_note)
+ {
+ std::vector<std::string> tokens;
+ split(tokens, line, ":");
+
+ if((*line.rbegin() == ':') || (tokens.size() > 1))
+ {
+ switch(current_note_line)
+ {
+ case 0:
+ currentNotes.type = tokens[0];
+ break;
+ case 1:
+ currentNotes.description = tokens[0];
+ break;
+ case 2:
+ currentNotes.difficultyClass = tokens[0];
+ break;
+ case 3:
+ std::istringstream ( tokens[1] ) >> currentNotes.difficultyMeter;
+ break;
+ case 4:
+ currentNotes.radarValues = tokens[0];
+ break;
+ default:
+ std::string msg = "Too much ':' for #NOTES in ";
+ msg.append(path);
+ logstdError("readSongFile", msg);
+ break;
+ }
+ current_note_line += 1;
+ }
+ else if(line[0] == ',')
+ {
+ currentNotes.noteData.push_back(currentLineNoteData);
+ currentLineNoteData.clear();
+ }
+ else if(line[0] == ';')
+ {
+ current_note_line = 0;
+ songFile.songNotes.push_back(currentNotes);
+ static const notes tempStruct;
+ currentNotes = tempStruct;
+ }
+ else
+ {
+ for(std::string::iterator c = line.begin(); c != line.end(); ++c) {
+ switch(*c)
+ {
+ case '0':
+ currentNoteData.push_back(None);
+ break;
+ case '1':
+ currentNoteData.push_back(Tap);
+ break;
+ case '2':
+ currentNoteData.push_back(Hold_begin);
+ break;
+ case '3':
+ currentNoteData.push_back(Hold_end);
+ break;
+ case '4':
+ currentNoteData.push_back(Roll);
+ break;
+ case 'M':
+ currentNoteData.push_back(Mine);
+ break;
+ case 'L':
+ currentNoteData.push_back(Lift);
+ break;
+ case 'F':
+ currentNoteData.push_back(Fake);
+ break;
+ }
+ }
+ currentLineNoteData.push_back(currentNoteData);
+ currentNoteData.clear();
+ }
+ }
+ }
+ if(!file.eof())
+ {
+ logstdError("readSongFile", "Line cannot be read");
+ }
+ file.close();
+ return 0;
+}
+
+std::vector<musicfile> loadSongs()
+{
+ std::vector<std::string> directories;
+ std::vector<std::string> smfiles;
+ std::vector<musicfile> songs;
+
+ GetDirectories(directories, songsPath);
+
+ for(std::vector<std::string>::iterator it = directories.begin(); it != directories.end(); ++it) {
+ GetSmFiles(smfiles, *it);
+ for(std::vector<std::string>::iterator ite = smfiles.begin(); ite != smfiles.end(); ++ite) {
+ musicfile songData;
+ std::string file = *it + *ite;
+ if(!readSongFile(file, songData))
+ songData.path = *it;
+ songs.push_back(songData);
+ }
+ }
+ return songs;
+}
+
diff --git a/main.cpp b/main.cpp
new file mode 100755
index 0000000..bc00afd
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,126 @@
+#include <SDL.h>
+
+#include "logging.h"
+#include "files.h"
+#include "display.h"
+#include "music.h"
+#include "game.h"
+#include "menu.h"
+
+#ifdef __cplusplus
+extern "C"
+#endif
+
+int main(int argc, char *argv[]) {
+
+ if (SDL_Init(SDL_INIT_EVERYTHING) != 0){
+ logSDLError("SDL_Init");
+ return 1;
+ }
+
+ if (TTF_Init()== -1){
+ logTTFError("TTF_Init");
+ return 1;
+ }
+
+ screen.font=TTF_OpenFont("/sdcard/LiberationMono-Regular.ttf", 14);
+ if(!screen.font) {
+ logTTFError("TTF_OpenFont: ");
+ }
+
+ screen.window = SDL_CreateWindow(screen.name, 100, 100, screen.width, screen.height, SDL_WINDOW_SHOWN);
+ if (screen.window == nullptr){
+ logSDLError("CreateWindow");
+ return 2;
+ }
+
+ screen.renderer = SDL_CreateRenderer(screen.window, -1,
+ SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
+ if(screen.renderer == nullptr)
+ screen.renderer = SDL_CreateRenderer(screen.window, -1, 0);
+
+ if (screen.renderer == nullptr){
+ logSDLError("CreateRenderer");
+ return 3;
+ }
+
+ if(Mix_OpenAudio(MIX_SAMPLERATE, MIX_DEFAULT_FORMAT, MIX_DEFAULT_CHANNELS, 1024) == -1) //Initialisation de l'API Mixer
+ logMixError("OpenAudio");
+
+ SDL_Event e;
+ bool quit = false;
+ bool playing;
+
+ std::vector<SDL_TouchFingerEvent> touchEvents;
+
+ while (!quit)
+ {
+ while (SDL_PollEvent(&e)){
+ switch (e.type ) {
+ case SDL_QUIT:
+ SDL_Log("SDL_QUIT");
+ quit = true;
+ break;
+ case SDL_KEYDOWN:
+ SDL_Log("SDL_KEYDOWN");
+ quit = true;
+ break;
+ case SDL_FINGERDOWN:
+ SDL_Log("SDL_FINGERDOWN");
+ touchEvents.push_back(e.tfinger);
+ break;
+ case SDL_WINDOWEVENT:
+ if(e.window.event == SDL_WINDOWEVENT_RESIZED)
+ {
+ screen.width = e.window.data1;
+ screen.height = e.window.data2;
+ SDL_DestroyWindow(screen.window);
+ screen.window = SDL_CreateWindow(screen.name, 100, 100, screen.width, screen.height, SDL_WINDOW_SHOWN);
+ if (screen.window == nullptr){
+ logSDLError("CreateWindow");
+ return 2;
+ }
+ }
+ break;
+ }
+ }
+
+ if(screen.state == STATE_INIT)
+ {
+ menu::init_menu();
+ } else if(screen.state == STATE_MENU)
+ {
+ menu::update_menu();
+ } else if(screen.state == STATE_PLAYING)
+ {
+// game::update();
+ }
+// if(!playing)
+// {
+// if(!init_game())
+// playing=true;
+// }
+// else if(quit)
+// quit_game();
+// else
+// update_game();
+ }
+
+ SDL_Log("Exited main loop");
+
+ Mix_CloseAudio();
+ SDL_Log("SDL_Mixer closed");
+ SDL_DestroyRenderer(screen.renderer);
+ SDL_Log("Renderer destroyed");
+ SDL_DestroyWindow(screen.window);
+ SDL_Log("Window destroyed");
+ TTF_CloseFont(screen.font);
+ screen.font=NULL;
+ SDL_Log("Font closed");
+ TTF_Quit();
+ SDL_Log("SDL_TTF closed");
+ SDL_Quit();
+ SDL_Log("SDL closed");
+
+ return 0;
+}
diff --git a/main_old.cpp b/main_old.cpp
new file mode 100755
index 0000000..5ee6a25
--- /dev/null
+++ b/main_old.cpp
@@ -0,0 +1,200 @@
+#include <SDL2/SDL.h>
+
+#include "logging.h"
+#include "files.h"
+#include "display.h"
+#include "music.h"
+
+int main(int argc, char** argv){
+ if (SDL_Init(SDL_INIT_EVERYTHING) != 0){
+ logSDLError(std::cout, "SDL_Init");
+ return 1;
+ }
+
+ SDL_Window *window = SDL_CreateWindow(WINDOW_NAME, 100, 100, SCREEN_WIDTH, SCREEN_HEIGHT,
+ SDL_WINDOW_SHOWN);
+ if (window == nullptr){
+ logSDLError(std::cout, "CreateWindow");
+ return 2;
+ }
+ SDL_Renderer *renderer = SDL_CreateRenderer(window, -1,
+ SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
+ if(renderer == nullptr)
+ renderer = SDL_CreateRenderer(window, -1, 0);
+
+ if (renderer == nullptr){
+ logSDLError(std::cout, "CreateRenderer");
+ return 3;
+ }
+
+ if(Mix_OpenAudio(MIX_SAMPLERATE, MIX_DEFAULT_FORMAT, MIX_DEFAULT_CHANNELS, 1024) == -1) //Initialisation de l'API Mixer
+ logMixError(std::cout, "OpenAudio");
+
+
+ Mix_Music *musique;
+
+ SDL_Texture *background;
+ SDL_Texture *image;
+
+ std::vector<music> songs = loadSongs();
+ for(std::vector<music>::iterator songData = songs.begin(); songData != songs.end(); ++songData) {
+ std::string path = songData->path + songData->background;
+ background = loadTexture(path, renderer);
+ path = songData->path + songData->banner;
+ image = loadTexture(path, renderer);
+ path = songData->path + songData->music;
+
+ if (background == nullptr || image == nullptr)
+ return 4;
+
+ SDL_RenderClear(renderer);
+
+ int bW, bH;
+ SDL_QueryTexture(background, NULL, NULL, &bW, &bH);
+ renderTexture(background, renderer, 0, 0);
+ renderTexture(background, renderer, bW, 0);
+ renderTexture(background, renderer, 0, bH);
+ renderTexture(background, renderer, bW, bH);
+
+ int iW, iH;
+ SDL_QueryTexture(image, NULL, NULL, &iW, &iH);
+ int x = SCREEN_WIDTH / 2 - iW / 2;
+ int y = SCREEN_HEIGHT / 2 - iH / 2;
+ renderTexture(image, renderer, x, y);
+
+ SDL_RenderPresent(renderer);
+
+ SDL_Event e;
+ bool quit = false;
+ bool playing = false;
+ unsigned int last_tick = SDL_GetTicks();
+ unsigned int last_update = 0;
+ int difficulty = 0;
+ int current_note = 0;
+ int current_line = 0;
+ int current_mes = 0;
+ std::vector<displaynote> displayednotes;
+ displaynote currentNote;
+
+ SDL_Texture *left;
+ SDL_Texture *right;
+ SDL_Texture *up;
+ SDL_Texture *down;
+
+ musique = Mix_LoadMUS(path.c_str());
+ if(musique == nullptr)
+ logMixError(std::cout, "LoadMUS");
+
+ left = loadTexture("left_arrow.png", renderer);
+ right = loadTexture("right_arrow.png", renderer);
+ up = loadTexture("up_arrow.png", renderer);
+ down = loadTexture("down_arrow.png", renderer);
+ unsigned int first_tick = SDL_GetTicks();
+ while (!quit)
+ {
+ while (SDL_PollEvent(&e)){
+ if (e.type == SDL_QUIT)
+ quit = true;
+ if (e.type == SDL_KEYDOWN)
+ quit = true;
+ if (e.type == SDL_MOUSEBUTTONDOWN)
+ quit = true;
+ }
+
+ if((SDL_GetTicks() - first_tick >= (SCREEN_HEIGHT-128*2)/5+songData->offset) && !playing)
+ {
+
+ if((musique != nullptr) && (Mix_PlayMusic(musique, -1) == -1))
+ logMixError(std::cout, "PlayMusic");
+ playing = true;
+ }
+
+
+ std::vector<Note> note = songData->songNotes[difficulty].noteData[current_mes][current_line];
+
+ int time = (1000/(songData->bpms[0].bpm/60))-60;
+
+ if(SDL_GetTicks() - last_tick >= time)
+ {
+ last_tick = SDL_GetTicks();
+
+ if(note[0] == Tap)
+ {
+ currentNote.texture = left;
+ currentNote.x = 10;
+ currentNote.y = SCREEN_HEIGHT;
+ displayednotes.push_back(currentNote);
+ }
+ if(note[1] == Tap)
+ {
+ currentNote.texture = up;
+ currentNote.x = 90;
+ currentNote.y = SCREEN_HEIGHT;
+ displayednotes.push_back(currentNote);
+ }
+ if(note[2] == Tap)
+ {
+ currentNote.texture = down;
+ currentNote.x = 170;
+ currentNote.y = SCREEN_HEIGHT;
+ displayednotes.push_back(currentNote);
+ }
+ if(note[3] == Tap)
+ {
+ currentNote.texture = right;
+ currentNote.x = 250;
+ currentNote.y = SCREEN_HEIGHT;
+ displayednotes.push_back(currentNote);
+ }
+ current_line += 1;
+ }
+
+/* renderTexture(background, renderer, 0, 0);
+ renderTexture(background, renderer, bW, 0);
+ renderTexture(background, renderer, 0, bH);
+ renderTexture(background, renderer, bW, bH);
+
+ renderTexture(image, renderer, x, y);
+*/
+ if(SDL_GetTicks() - last_tick >= 20)
+{
+ SDL_RenderClear(renderer);
+
+ renderTexture(background, renderer, 0, 0);
+ renderTexture(background, renderer, bW, 0);
+ renderTexture(background, renderer, 0, bH);
+ renderTexture(background, renderer, bW, bH);
+
+ renderTexture(image, renderer, x, y);
+
+ for(std::vector<displaynote>::iterator show_note = displayednotes.begin(); show_note != displayednotes.end(); ++show_note) {
+ renderTexture(show_note->texture, renderer, show_note->x, show_note->y);
+ if(SDL_GetTicks() - last_tick >= 1)
+ {
+ last_update = SDL_GetTicks();
+ show_note->y -= 5;
+ }
+ }
+ SDL_RenderPresent(renderer);
+}
+
+ if(songData->songNotes[difficulty].noteData[current_mes].size() <= current_line)
+ {
+ current_line = 0;
+ current_mes +=1;
+ }
+
+ }
+
+ SDL_DestroyTexture(background);
+ SDL_DestroyTexture(image);
+ if(musique) Mix_FreeMusic(musique);
+}
+
+ Mix_CloseAudio();
+ SDL_DestroyRenderer(renderer);
+ SDL_DestroyWindow(window);
+ SDL_Quit();
+
+ return 0;
+}
diff --git a/menu.cpp b/menu.cpp
new file mode 100755
index 0000000..d87bbdd
--- /dev/null
+++ b/menu.cpp
@@ -0,0 +1,65 @@
+#include "menu.h"
+
+namespace menu
+{
+ std::vector<musicfile> songs;
+ SDL_Texture *background;
+
+int init_menu()
+{
+ SDL_Texture *image;
+
+ songs = loadSongs();
+
+
+ screen.state = STATE_MENU;
+}
+
+int update_menu()
+{
+ int height = 0;
+ for(std::vector<musicfile>::iterator songData = songs.begin(); songData != songs.end(); ++songData) {
+
+ std::string path = songData->path + songData->background;
+ background = loadTexture(path, screen.renderer);
+ path = songData->path + songData->banner;
+ image = loadTexture(path, screen.renderer);
+ path = songData->path + songData->file;
+
+ if (background == nullptr || image == nullptr)
+ continue;
+
+ SDL_RenderClear(screen.renderer);
+
+ SDL_Color color={255,0,0};
+
+ SDL_Surface *text = TTF_RenderText_Blended(screen.font, path.c_str(), color);
+ SDL_Texture* texture = SDL_CreateTextureFromSurface(screen.renderer, text);
+ renderTexture(texture, screen.renderer, 0.5f, 0.5f);
+
+
+ int w, h;
+
+ float bW, bH;
+ SDL_QueryTexture(background, NULL, NULL, &w, &h);
+ bW = (float)w / (float)screen.width;
+ bH = (float)h / (float)screen.height;
+
+ float iW, iH;
+ SDL_QueryTexture(image, NULL, NULL, &w, &h);
+ //iW = 0.5f - ( / ( ) /2;
+ //iH = 0.5f - ( (float)h / (float)screen.height ) /2;
+ iW = (float)screen.width - (float)w;
+ iH = height;
+
+ renderTexture(background, renderer, bW, bH);
+ renderTexture(image, renderer, iW, iH);
+
+ SDL_RenderPresent(screen.renderer);
+ height += height + 0.02f;
+ }
+
+}
+
+
+};