Release/fileio.cpp

   1 #include "FileIO.h"
   2
   3 #include "ScreenNames.h"
   4 #include "RescourceKeys.h"
   5
   6 enum gameType { arcade = 1, life = 2 };
   7
   8 FileIO::FileIO()
   9 {
  10         password = "Test";
  11 }
  12 FileIO::FileIO(FileIO* fio)
  13 {
  14         rsc = fio->rsc;
  15         password = "Test";
  16 }
  17 FileIO::FileIO(ResourceMaster* rscrc)
  18 {
  19         rsc = rscrc;
  20         password = "Test";
  21 }
  22
  23
  24 FileIO::~FileIO()
  25 {
  26 }
  27
  28 //old methods
  29
  30 void FileIO::storeGameText(std::vector<std::string> item) {
  31         rsc->gameText = item;
  32 }
  33 //problematic
  34 void FileIO::saveUserData(int data, int line) {
  35         std::ifstream saveFile("data/save.txt");
  36         std::ofstream tempFile("data/temp.txt");
  37
  38         std::array<std::string,3> currentData;
  39         int counter = 0;
  40         while (!saveFile.eof()) {
  41                 std::string buffer;
  42                 std::getline(saveFile, buffer);
  43                 if (buffer != "" && buffer != "\n" && buffer != " ") {
  44                         currentData.at(counter) = buffer;
  45                         std::cout << buffer << "\n";
  46                         counter++;
  47                 }
  48         }
  49
  50         counter = 0;
  51         while (counter < 3) {
  52                 if (line != counter + 1) {
  53                         tempFile << currentData.at(counter) + "\n";
  54                 }
  55                 else {
  56                         tempFile << std::to_string(data) + "\n";
  57                 }
  58                 counter++;
  59         }
  60
  61         saveFile.close();
  62         tempFile.close();
  63
  64         std::remove("data/save.txt");
  65         std::rename("data/temp.txt", "data/save.txt");
  66 }
  67
  68 void FileIO::saveScoreData(int gamemode, int data, int line) {
  69         std::ifstream saveFile("data/scores.txt");
  70         std::ofstream tempFile("data/temp.txt");
  71         std::array<std::string, 8> currentData;
  72         int counter = 0;
  73         while (!saveFile.eof()) {
  74                 std::string buffer;
  75                 std::getline(saveFile, buffer);
  76                 if (buffer != "" && buffer != "\n" && buffer != " ") {
  77                         currentData.at(counter) = buffer;
  78                         counter++;
  79                         std::cout << buffer << "\n";
  80                 }
  81         }
  82         std::cout << "skip";
  83         counter = 0;
  84         while (counter < 8) {
  85                 if (counter % 2 != gamemode - 1 || counter / 2 + 1 != line) {
  86                         tempFile << currentData.at(counter) + "\n";
  87                 }
  88                 else {
  89                         tempFile << std::to_string(data) + "\n";
  90                 }
  91                 counter++;
  92         }
  93
  94         saveFile.close();
  95         tempFile.close();
  96
  97         std::remove("data/scores.txt");
  98         std::rename("data/temp.txt", "data/scores.txt");
  99 }
 100
 101 std::vector<std::string> FileIO::loadLanguage(std::string path)
 102 {
 103         std::ifstream langData;
 104         langData.open(path);
 105
 106         std::string text;
 107         std::vector<std::string> result;
 108         while (std::getline(langData, text)) {
 109                 std::cout << text << "\n";
 110                 if (!text.empty()) {
 111                         if (text.length() == 1 && text.at(0) != ' ') {
 112                                 result.push_back(text);
 113                         }
 114                         else if (text.at(0) != '/' && text.at(1) != '/') {
 115                                 result.push_back(text);
 116                         }
 117                 }
 118         }
 119         langData.close();
 120         storeGameText(result);
 121         return result;
 122 }
 123
 124 int FileIO::loadUserData(int line) {
 125
 126         std::string storedData;
 127         std::ifstream data;
 128         data.open("Data/save.txt");
 129
 130         std::array<std::string, 3> currentData;
 131         int counter = 0;
 132         while (!data.eof()) {
 133                 std::string buffer;
 134                 std::getline(data, buffer);
 135                 if (buffer != "" && buffer != "\n" && buffer != " ") {
 136                         currentData.at(counter) = buffer;
 137                         std::cout << buffer << "\n";
 138                         counter++;
 139                 }
 140         }
 141         data.close();
 142
 143         int intStoredData;
 144         std::stringstream convert(currentData.at(line - 1));
 145         if (!(convert >> intStoredData)) {
 146                 intStoredData = -1;
 147                 std::cout << "err\n";
 148         }
 149         return intStoredData;
 150 }
 151
 152 int FileIO::loadScoreData(int gamemode, int line) {
 153         std::string storedData;
 154         std::ifstream data;
 155         data.open("Data/scores.txt");
 156         std::array<std::string, 8> currentData;
 157         int counter = 0;
 158
 159         while (!data.eof()) {
 160                 std::string buffer;
 161                 std::getline(data, buffer);
 162                 if (buffer != "" && buffer != "\n" && buffer != " ") {
 163                         currentData.at(counter) = buffer;
 164                         std::cout << buffer;
 165                         counter++;
 166                 }
 167         }
 168         std::cout << "\t";
 169
 170         data.close();
 171
 172         if (gamemode == arcade) {
 173                 line = (line - 1) * 2 + 1;
 174         }
 175         else if (gamemode == life) {
 176                 line = line * 2;
 177         }
 178
 179         int intStoredData;
 180         std::stringstream convert(currentData.at(line - 1));
 181         if (!(convert >> intStoredData)) {
 182                 intStoredData = -1;
 183                 std::cout << "err\n";
 184         }
 185         return intStoredData;
 186 }
 187
 188 /*
 189 void FileIO::loadMenuItems()
 190 {
 191         std::vector<SDL_Texture*> menuTextures;
 192
 193         for (int fileName = LangBG; fileName <= GenericBar; fileName++) {
 194                 SDL_Texture* sdlText = loadTexture("Art/" + std::to_string(fileName + 1) + ".png");
 195                 if (sdlText == NULL) {
 196                         std::cout << SDL_GetError() << " Number " << (fileName + 1) << ".png\n";
 197                 }
 198                 menuTextures.push_back(sdlText);
 199         }
 200         storeTextures(menuTextures);
 201 }
 202
 203 void FileIO::loadMenuAnimations() {
 204         std::vector<std::vector<SDL_Texture*>> menuAnimations;
 205
 206         for (int animationFolder = WhiteBlueBG; animationFolder <= WhiteBlueBG; animationFolder++) {
 207                 std::vector<SDL_Texture*> sdlTextList;
 208                 for (int i = 1; i <= 57; i++) {
 209                         sdlTextList.push_back(loadTexture("Art/" + std::to_string(animationFolder) + "/ (" + std::to_string(i) + ").png"));
 210                 }
 211                 if (sdlTextList.front() == NULL) {
 212                         std::cout << SDL_GetError();
 213                 }
 214                 menuAnimations.push_back(sdlTextList);
 215         }
 216         storeAnimations(menuAnimations);
 217 }
 218
 219
 220 void FileIO::loadGameAnimations()
 221 {
 222         std::vector< std::vector<SDL_Texture*>> gameAnimations;
 223 }
 224
 225 void FileIO::loadGameGraphics()
 226 {
 227         std::vector<SDL_Texture*> gameGraphics;
 228 }
 229
 230 SDL_Texture* FileIO::loadTexture(std::string path) {
 231
 232         SDL_Texture* newTexture = NULL;
 233         SDL_Surface* loadedSurface = IMG_Load(path.c_str());
 234
 235         newTexture = SDL_CreateTextureFromSurface(rsc->rendPtr, loadedSurface);
 236         SDL_FreeSurface(loadedSurface);
 237
 238         return newTexture;
 239 }*/
 240
 241 //new methods
 242
 243 //problematic
 244 SDL_Texture* FileIO::loadSpecificImage(std::string path, int image) {
 245         return extractSpecificTexture(path, image);
 246 }
 247 std::vector<SDL_Texture*> FileIO::loadSpecificZip(std::string path) {
 248         return extractTexturesFromZip(path);
 249 }
 250 void FileIO::loadBGZip() {
 251         rsc->gameBG = extractTexturesFromZip("BG.zip");
 252 }
 253 void FileIO::loadTexturesZip() {
 254         rsc->gameGraphics = extractTexturesFromZip("Textures.zip");
 255 }
 256 void FileIO::loadAnimationsZip() {
 257         rsc->gameAnimations.push_back(extractTexturesFromZip("(0).zip"));
 258         /**/
 259         for (int i = 1; i <= 36; i++) {
 260                 rsc->gameAnimations.push_back(extractTexturesFromZip(" (" + std::to_string(i) + ").zip"));
 261         }
 262 }
 263 void FileIO::loadBGMZip() {
 264         rsc->gameBGM = extractBGMZip("BGM.zip");
 265 }
 266 void FileIO::loadSFXZip() {
 267         rsc->gameSFX = extractSFXZip("SFX.zip");
 268 }
 269
 270 SDL_Texture* FileIO::extractSpecificTexture(std::string path, int image) {
 271         unzFile genericZip = unzOpen(path.c_str());
 272         unz_global_info ugi;
 273         unzGetGlobalInfo(genericZip, &ugi);
 274
 275         SDL_Texture* specificText;
 276         SDL_RWops* rw = NULL;
 277         uLong i;
 278         std::cout << "Extracting" << "\n";
 279         for (i = 0; i < ugi.number_entry; i++) {
 280                 unz_file_info ufi;
 281                 char filename[256];
 282                 unzGetCurrentFileInfo(genericZip, &ufi, filename, sizeof(filename), NULL, 0, NULL, 0);
 283                 std::string name = getZipFileName(ufi, genericZip);
 284                 if (name == std::to_string(image)) {
 285                         uInt size_buf = ufi.uncompressed_size;
 286                         void*buf = (void*)malloc(size_buf);
 287                         int err = unzOpenCurrentFilePassword(genericZip, password);
 288                         if (err != UNZ_OK) {
 289                                 printf("errPass\n");
 290                         }
 291                         err = unzReadCurrentFile(genericZip, buf, size_buf);
 292                         if (err < 0) {
 293                                 printf("ErrReadZip\n");
 294                         }
 295                         rw = SDL_RWFromMem(buf, size_buf);
 296                         if (rw == NULL) {
 297                                 printf("RW\n");
 298                         }
 299                         SDL_Surface* surf = IMG_Load_RW(rw, 1);
 300                         if (surf == NULL) {
 301                                 std::cout << "surf\n";
 302                         }
 303                         specificText = SDL_CreateTextureFromSurface(rsc->rendPtr, surf);
 304                         if (specificText == NULL) {
 305                                 std::cout << "text\n";
 306                         }
 307                         SDL_FreeSurface(surf);
 308                         free(buf);
 309                         unzClose(genericZip);
 310                         return specificText;
 311                 }
 312                 unzGoToNextFile(genericZip);
 313         }
 314 }
 315
 316 std::vector<Mix_Music*> FileIO::extractBGMZip(std::string path) {
 317         unzFile bgmZip = unzOpen(path.c_str());
 318         unz_global_info ugi;
 319         unzGetGlobalInfo(bgmZip, &ugi);
 320
 321         std::vector<Mix_Music*> rtnVect(ugi.number_entry);
 322         std::vector<Mix_Music*>::iterator it;
 323
 324         SDL_RWops* rw = NULL;
 325         uLong i;
 326         std::cout << "Extracting" << "\n";
 327         for (i = 0; i < ugi.number_entry; i++) {
 328                 unz_file_info ufi;
 329                 char filename[256];
 330                 unzGetCurrentFileInfo(bgmZip, &ufi, filename, sizeof(filename), NULL, 0, NULL, 0);
 331
 332                 uInt size_buf = ufi.uncompressed_size;
 333                 //std::cout << size_buf << "\n";
 334                 void* buf = (void*)malloc(size_buf);
 335                 int err = unzOpenCurrentFilePassword(bgmZip, password);
 336                 if (err != UNZ_OK)
 337                 {
 338                         printf("errPass\n");
 339                 }
 340
 341                 err = unzReadCurrentFile(bgmZip, buf, size_buf);
 342                 if (err < 0) {
 343                         std::cout << "errunzBGM\n";
 344                 }
 345                 rw = SDL_RWFromMem(buf, size_buf);
 346                 if (rw == NULL) {
 347                         std::cout << "RW\n";
 348                 }
 349
 350                 Mix_Music* temp = Mix_LoadMUS_RW(rw, 1);
 351
 352                 std::string name = getZipFileName(ufi, bgmZip);
 353                 char chars[] = "()-.wav";
 354
 355                 for (unsigned int i = 0; i < strlen(chars); ++i)
 356                 {
 357                         // you need include <algorithm> to use general algorithms like std::remove()
 358                         name.erase(std::remove(name.begin(), name.end(), chars[i]), name.end());
 359                 }
 360                 int index = stoi(name) - 1;
 361
 362                 std::cout << index << "\n";
 363
 364                 it = rtnVect.begin() + index;
 365                 rtnVect.at(index) = temp;
 366                 unzGoToNextFile(bgmZip);
 367         }
 368         unzClose(bgmZip);
 369         return rtnVect;
 370 }
 371
 372 std::vector<Mix_Chunk*> FileIO::extractSFXZip(std::string path) {
 373         unzFile sfxZip = unzOpen(path.c_str());
 374         unz_global_info ugi;
 375         unzGetGlobalInfo(sfxZip, &ugi);
 376
 377         std::vector<Mix_Chunk*> rtrnVector(ugi.number_entry);
 378
 379         SDL_RWops* rw = NULL;
 380         uLong i;
 381         std::cout << "Extracting" << "\n";
 382         for (i = 0; i < ugi.number_entry; i++) {
 383                 unz_file_info ufi;
 384                 char filename[256];
 385                 unzGetCurrentFileInfo(sfxZip, &ufi, filename, sizeof(filename), NULL, 0, NULL, 0);
 386
 387                 uInt size_buf = ufi.uncompressed_size;
 388                 //std::cout << size_buf << "\n";
 389                 void* buf = (void*)malloc(size_buf);
 390                 int err = unzOpenCurrentFilePassword(sfxZip, password);
 391                 if (err != UNZ_OK)
 392                 {
 393                         printf("errPass\n");
 394                 }
 395
 396                 err = unzReadCurrentFile(sfxZip, buf, size_buf);
 397                 if (err < 0) {
 398                         std::cout << "errunzSFX\n";
 399                 }
 400                 rw = SDL_RWFromMem(buf, size_buf);
 401                 if (rw == NULL) {
 402                         std::cout << "RW\n";
 403                 }
 404                 Mix_Chunk* temp = Mix_LoadWAV_RW(rw, 1);
 405                 std::string name = getZipFileName(ufi, sfxZip);
 406                 char chars[] = "()-.wav";
 407
 408                 for (unsigned int i = 0; i < strlen(chars); ++i)
 409                 {
 410                         // you need include <algorithm> to use general algorithms like std::remove()
 411                         name.erase(std::remove(name.begin(), name.end(), chars[i]), name.end());
 412                 }
 413                 int index = stoi(name) - 1;
 414
 415                 std::cout << index << "\n";
 416                 rtrnVector.at(index) = (temp);
 417
 418                 unzGoToNextFile(sfxZip);
 419         }
 420         unzClose(sfxZip);
 421         return rtrnVector;
 422 }
 423
 424 std::vector<SDL_Texture*> FileIO::extractTexturesFromZip(std::string path) {
 425         unzFile textureZip = unzOpen(path.c_str());
 426         unz_global_info ugi;
 427         unzGetGlobalInfo(textureZip, &ugi);
 428
 429         std::vector<SDL_Texture*> rtrnVect(ugi.number_entry);
 430
 431         SDL_RWops* rw = NULL;
 432         uLong i;
 433         std::cout << "Extracting" << "\n";
 434         for (i = 0; i < ugi.number_entry; i++) {
 435                 unz_file_info ufi;
 436                 char filename[256];
 437                 unzGetCurrentFileInfo(textureZip, &ufi, filename, sizeof(filename), NULL, 0, NULL, 0);
 438
 439                 uInt size_buf = ufi.uncompressed_size;
 440                 //std::cout << size_buf << "\n";
 441                 void* buf = (void*)malloc(size_buf);
 442                 int err = unzOpenCurrentFilePassword(textureZip, password);
 443                 if (err != UNZ_OK)
 444                 {
 445                         printf("errPass\n");
 446                 }
 447
 448                 err = unzReadCurrentFile(textureZip, buf, size_buf);
 449                 if (err < 0) {
 450                         std::cout << "errunzTxt\n";
 451                 }
 452                 rw = SDL_RWFromMem(buf, size_buf);
 453                 if (rw == NULL) {
 454                         std::cout << "RW\n";
 455                 }
 456                 SDL_Surface* surf = IMG_Load_RW(rw, 1);
 457                 if (surf == NULL) {
 458                         std::cout << "surf\n";
 459                 }
 460                 SDL_Texture* text = SDL_CreateTextureFromSurface(rsc->rendPtr, surf);
 461                 if (text == NULL) {
 462                         std::cout << "text\n";
 463                 }
 464
 465                 std::string name = getZipFileName(ufi, textureZip);
 466
 467                 char chars[] = "()-.png";
 468
 469                 for (unsigned int i = 0; i < strlen(chars); ++i)
 470                 {
 471                         // you need include <algorithm> to use general algorithms like std::remove()
 472                         name.erase(std::remove(name.begin(), name.end(), chars[i]), name.end());
 473                 }
 474                 int index = stoi(name) - 1;
 475
 476                 std::cout << index << "\n";
 477
 478                 rtrnVect.at(index) = text;
 479
 480                 SDL_FreeSurface(surf);
 481                 free(buf);
 482
 483                 unzGoToNextFile(textureZip);
 484         }
 485         unzClose(textureZip);
 486         return rtrnVect;
 487 }
 488
 489 char* FileIO::getZipFileName(unz_file_info ufi, unzFile uf) {
 490         char *fileName = (char *)malloc(ufi.size_filename + 1);
 491         unzGetCurrentFileInfo(uf, &ufi, fileName, ufi.size_filename + 1, NULL, 0, NULL, 0);
 492         fileName[ufi.size_filename] = '\0';
 493         return fileName;
 494 }
 495
 496 void FileIO::eraseUserData()
 497 {
 498         for (int line = 1; line <= 3; line++) {
 499                 saveUserData(0, line);
 500                 saveUserData(0, line);
 501                 saveUserData(0, line);
 502         }
 503         for (int line = 1; line <= 4; line++) {
 504                 std::cout << "skipyyy";
 505                 saveScoreData(arcade, 0, line);
 506                 saveScoreData(life, 0, line);
 507         }
 508 }
 509
 510 std::vector<int> FileIO::splitInt(std::string str, char delimiter) {
 511         std::vector<int> internal;
 512         std::stringstream ss(str);
 513         std::string result;
 514
 515         while (std::getline(ss, result, delimiter)) {
 516                 int i = atoi(result.c_str());
 517                 internal.push_back(i);
 518         }
 519         return internal;
 520 }
 521 std::vector<std::string> FileIO::split(std::string str, char delimiter) {
 522         std::vector<std::string> internal;
 523         std::stringstream ss(str);
 524         std::string result;
 525
 526         while (std::getline(ss, result, delimiter)) {
 527                 internal.push_back(result);
 528         }
 529         return internal;
 530 }