added usings to reduce the typing.

KarvinJ · KarvinJ · commit a583cd956c42 · 2025-04-15T16:58:07.000-04:00
diff --git a/src/assetsManager.cpp b/src/assetsManager.cpp
@@ -1,18 +1,21 @@
 #include "assetsManager.h"
 
-std::vector<Kana> loadAssets()
+using std::vector;
+using std::string;
+
+vector<Kana> loadAssets()
 {
-    std::vector<Kana> kanas;
+    vector<Kana> kanas;
     kanas.reserve(142);
 
-    std::string audioPath = "assets/sounds/";
-    std::string hiraganaImgsPath = "assets/img/hiraganas/";
-    std::string audioExtension = ".mp3";
-    std::string imageExtension = ".png";
-    std::string hiraganaGifPath = "assets/gifs/hiraganas/";
-    std::string gifExtension = ".gif";
+    string audioPath = "assets/sounds/";
+    string hiraganaImgsPath = "assets/img/hiraganas/";
+    string audioExtension = ".mp3";
+    string imageExtension = ".png";
+    string hiraganaGifPath = "assets/gifs/hiraganas/";
+    string gifExtension = ".gif";
 
-    std::string kanaNames[] = {
+    string kanaNames[] = {
         "a", "e", "i", "o", "u",
         "ka", "ga", "ki", "gi", "ku",
         "gu", "ke", "ge", "ko", "go",
@@ -30,17 +33,17 @@ std::vector<Kana> loadAssets()
         "wa", "wo", "n"
     };
 
-    for (std::string &kanaName : kanaNames)
+    for (string &kanaName : kanaNames)
     {
-        std::string actualAudioPath = audioPath + kanaName + audioExtension;
+        string actualAudioPath = audioPath + kanaName + audioExtension;
         Sound actualSound = LoadSound(actualAudioPath.c_str());
         SetSoundVolume(actualSound, 0.8);
 
-        std::string actualImagePath = hiraganaImgsPath + kanaName + imageExtension;
+        string actualImagePath = hiraganaImgsPath + kanaName + imageExtension;
         Texture2D actualTexture = LoadTexture(actualImagePath.c_str());
         Rectangle kanaBounds = {40, 40, (float)actualTexture.width, (float)actualTexture.height};
 
-        std::string actualGifPath = hiraganaGifPath + kanaName + gifExtension;
+        string actualGifPath = hiraganaGifPath + kanaName + gifExtension;
 
         int animationFrames = 0;
         // Since I'm loading images, the ram consumption will go up.
@@ -58,20 +61,20 @@ std::vector<Kana> loadAssets()
         kanas.push_back({kanaName, kanaBounds, actualTexture, actualSound, drawKanaTexture, kanaAnimation, animationFrames});
     }
 
-    std::string katakanaImgsPath = "assets/img/katakanas/";
-    std::string katakanaGifPath = "assets/gifs/katakanas/";
+    string katakanaImgsPath = "assets/img/katakanas/";
+    string katakanaGifPath = "assets/gifs/katakanas/";
 
     int actualMaxSize = kanas.size();
 
     for (int i = 0; i < actualMaxSize; i++)
     {
         auto actualKana = kanas[i];
 
-        std::string actualImagePath = katakanaImgsPath + actualKana.name + imageExtension;
+        string actualImagePath = katakanaImgsPath + actualKana.name + imageExtension;
         Texture2D actualTexture = LoadTexture(actualImagePath.c_str());
         Rectangle kanaBounds = {40, 40, (float)actualTexture.width, (float)actualTexture.height};
 
-        std::string actualGifPath = katakanaGifPath + actualKana.name + gifExtension;
+        string actualGifPath = katakanaGifPath + actualKana.name + gifExtension;
 
         int animationFrames = 0;
         Image kanaAnimation = LoadImageAnim(actualGifPath.c_str(), &animationFrames);
@@ -84,9 +87,9 @@ std::vector<Kana> loadAssets()
     return kanas;
 }
 
-std::string handleMissingGifName(std::string kanaName)
+string handleMissingGifName(string kanaName)
 {
-    std::string actualName = kanaName;
+    string actualName = kanaName;
 
     if (actualName.compare("ji") == 0)
     {
diff --git a/src/assetsManager.h b/src/assetsManager.h
@@ -2,7 +2,7 @@
 
 #include <raylib.h>
 #include <vector>
-#include <iostream>
+#include <string>
 
 typedef struct
 {
diff --git a/src/fileManager.cpp b/src/fileManager.cpp
@@ -1,18 +1,19 @@
 #include "fileManager.h"
+#include <fstream>
 
-std::vector<std::string> saveInitialHighScores()
+vector<string> saveInitialHighScores()
 {
-    std::vector<std::string> highScores;
+    vector<string> highScores;
     highScores.reserve(9);
 
     std::ofstream highScoresFile("assets/high-scores.txt");
 
-    std::string name = "aaa";
+    string name = "aaa";
 
     for (int i = 8; i > 0; i--)
     {
-        std::string scoreString = std::to_string(i * 100);
-        std::string fullScoreString = name + "             " + scoreString;
+        string scoreString = std::to_string(i * 100);
+        string fullScoreString = name + "             " + scoreString;
 
         if (i == 1)
         {
@@ -31,7 +32,7 @@ std::vector<std::string> saveInitialHighScores()
     return highScores;
 }
 
-std::string extractLastNChars(std::string const &str, size_t n)
+string extractLastNChars(string const &str, size_t n)
 {
     if (str.size() < n)
     {
@@ -41,19 +42,19 @@ std::string extractLastNChars(std::string const &str, size_t n)
     return str.substr(str.size() - n);
 }
 
-std::vector<HighScore> getFullScoreData(std::vector<std::string> highScores)
+vector<HighScore> getFullScoreData(vector<string> highScores)
 {
-    std::vector<HighScore> scores;
+    vector<HighScore> scores;
     scores.reserve(9);
 
     int rank = 1;
 
     for (auto &highScore: highScores)
     {
-        std::string scoreString = extractLastNChars(highScore, 3);
+        string scoreString = extractLastNChars(highScore, 3);
         int score = stoi(scoreString);
 
-        std::string nameString = highScore.substr(0, 3);
+        string nameString = highScore.substr(0, 3);
         
         scores.push_back({rank, nameString, score});
         rank++;
@@ -62,24 +63,24 @@ std::vector<HighScore> getFullScoreData(std::vector<std::string> highScores)
     return scores;
 }
 
-std::vector<std::string> saveActualHighScores(std::vector<std::string> highScores, int actualScore, std::string playerName)
+vector<string> saveActualHighScores(vector<string> highScores, int actualScore, string playerName)
 {
-    std::vector<std::string> actualScores;
+    vector<string> actualScores;
     actualScores.reserve(9);
 
     bool actualScoreWasAdded = false;
 
     for (size_t i = 0; i < highScores.size(); i++)
     {
-        std::string highScore = highScores[i];
+        string highScore = highScores[i];
 
-        std::string scoreString = extractLastNChars(highScore, 3);
+        string scoreString = extractLastNChars(highScore, 3);
 
         int score = stoi(scoreString);
 
         if (!actualScoreWasAdded && actualScore > score)
         {
-            std::string fullScore = playerName + "             " + std::to_string(actualScore);
+            string fullScore = playerName + "             " + std::to_string(actualScore);
             actualScores.push_back(fullScore);
             actualScoreWasAdded = true;
         }
@@ -98,7 +99,7 @@ std::vector<std::string> saveActualHighScores(std::vector<std::string> highScore
         //I can create a infinite loop and it will create a really big file and create a high ram consumption.
         for (size_t i = 0; i < actualScores.size(); i++)
         {
-            std::string fullScoreString = actualScores[i];
+            string fullScoreString = actualScores[i];
     
             if (i == actualScores.size() - 1)
             {
@@ -118,9 +119,9 @@ std::vector<std::string> saveActualHighScores(std::vector<std::string> highScore
     return highScores;
 }
 
-std::vector<std::string> loadHighScores()
+vector<string> loadHighScores()
 {
-    std::vector<std::string> scores;
+    vector<string> scores;
     scores.reserve(9);
 
     std::ifstream highScoresFile("assets/high-scores.txt");
@@ -130,7 +131,7 @@ std::vector<std::string> loadHighScores()
         return saveInitialHighScores();
     }
 
-    for (std::string line; getline(highScoresFile, line);)
+    for (string line; getline(highScoresFile, line);)
     {
         scores.push_back(line);
     }
@@ -149,7 +150,7 @@ void saveScore(int score)
     highScoreFile.close();
 }
 
-void savePlayerName(std::string playerName)
+void savePlayerName(string playerName)
 {
     std::ofstream playerNameFile("assets/player.txt");
 
@@ -158,9 +159,9 @@ void savePlayerName(std::string playerName)
     playerNameFile.close();
 }
 
-std::string loadPlayerName()
+string loadPlayerName()
 {
-    std::string playerName;
+    string playerName;
 
     std::ifstream playerNameFile("assets/player.txt");
 
@@ -179,7 +180,7 @@ std::string loadPlayerName()
 
 int loadHighScore()
 {
-    std::string highScoreText;
+    string highScoreText;
 
     std::ifstream highScoreFile("assets/high-score.txt");
 
diff --git a/src/fileManager.h b/src/fileManager.h
@@ -1,29 +1,33 @@
 #pragma once
 
 #include <vector>
-#include <fstream>
+#include <string>
+
+//with usings I can remove the need to the of the extra typing string, vector, etc..
+using std::vector;
+using std::string;
 
 typedef struct
 {
     int rank;
-    std::string name;
+    string name;
     int score;
 } HighScore;
 
-std::vector<std::string> saveInitialHighScores();
+vector<string> saveInitialHighScores();
 
-std::string extractLastNChars(std::string const &str, size_t n);
+string extractLastNChars(string const &str, size_t n);
 
-std::vector<HighScore> getFullScoreData(std::vector<std::string> highScores);
+vector<HighScore> getFullScoreData(vector<string> highScores);
 
-std::vector<std::string> saveActualHighScores(std::vector<std::string> highScores, int actualScore, std::string playerName);
+vector<string> saveActualHighScores(vector<string> highScores, int actualScore, string playerName);
 
-std::vector<std::string> loadHighScores();
+vector<string> loadHighScores();
 
 void saveScore(int score);
 
-void savePlayerName(std::string playerName);
+void savePlayerName(string playerName);
 
-std::string loadPlayerName();
+string loadPlayerName();
 
 int loadHighScore();
diff --git a/src/main.cpp b/src/main.cpp
@@ -17,7 +17,7 @@ void updateHighScore(int &score, int &highScore)
     }
 }
 
-void toLowerCase(std::string &string)
+void toLowerCase(string &string)
 {
     // Manual converting each character to lowercase using ASCII values
     for (char &character : string)
@@ -57,7 +57,7 @@ int main()
 
     int highScore = loadHighScore();
 
-    std::string playerName = loadPlayerName();
+    string playerName = loadPlayerName();
 
     bool isHighScoreScreen = false;
 
@@ -66,9 +66,9 @@ int main()
         isHighScoreScreen = true;
     }
 
-    std::vector<std::string> highScores = loadHighScores();
+    vector<string> highScores = loadHighScores();
 
-    std::vector<HighScore> fullScores = getFullScoreData(highScores);
+    vector<HighScore> fullScores = getFullScoreData(highScores);
 
     int attempts = 0;
 
@@ -78,7 +78,7 @@ int main()
 
     InitAudioDevice();
 
-    std::vector<Kana> kanas = loadAssets();
+    vector<Kana> kanas = loadAssets();
 
     // there are 71 hiragana + 71 katakanas = 142.
     int totalKanas = kanas.size() - 1;
@@ -219,7 +219,7 @@ int main()
         mouseBounds.x = mousePosition.x;
         mouseBounds.y = mousePosition.y;
 
-        std::string actualKanaName = answer;
+        string actualKanaName = answer;
 
         if (!isLearningMode && !isHighScoreScreen)
         {
@@ -422,7 +422,7 @@ int main()
 
             if (IsKeyPressed(KEY_SPACE))
             {
-                std::string name = answer;
+                string name = answer;
                 name.pop_back();
                 toLowerCase(name);
 

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`#include <raylib.h>`
`4`	`4`	`#include <vector>`
`5`		`-#include <iostream>`
	`5`	`+#include <string>`
`6`	`6`
`7`	`7`	`typedef struct`
`8`	`8`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,19 @@`
`1`	`1`	`#include "fileManager.h"`
	`2`	`+#include <fstream>`
`2`	`3`
`3`		`-std::vector<std::string> saveInitialHighScores()`
	`4`	`+vector<string> saveInitialHighScores()`
`4`	`5`	`{`
`5`		`- std::vector<std::string> highScores;`
	`6`	`+ vector<string> highScores;`
`6`	`7`	`highScores.reserve(9);`
`7`	`8`
`8`	`9`	`std::ofstream highScoresFile("assets/high-scores.txt");`
`9`	`10`
`10`		`- std::string name = "aaa";`
	`11`	`+ string name = "aaa";`
`11`	`12`
`12`	`13`	`for (int i = 8; i > 0; i--)`
`13`	`14`	`{`
`14`		`- std::string scoreString = std::to_string(i * 100);`
`15`		`- std::string fullScoreString = name + " " + scoreString;`
	`15`	`+ string scoreString = std::to_string(i * 100);`
	`16`	`+ string fullScoreString = name + " " + scoreString;`
`16`	`17`
`17`	`18`	`if (i == 1)`
`18`	`19`	`{`
`@@ -31,7 +32,7 @@ std::vector<std::string> saveInitialHighScores()`
`31`	`32`	`return highScores;`
`32`	`33`	`}`
`33`	`34`
`34`		`-std::string extractLastNChars(std::string const &str, size_t n)`
	`35`	`+string extractLastNChars(string const &str, size_t n)`
`35`	`36`	`{`
`36`	`37`	`if (str.size() < n)`
`37`	`38`	`{`
`@@ -41,19 +42,19 @@ std::string extractLastNChars(std::string const &str, size_t n)`
`41`	`42`	`return str.substr(str.size() - n);`
`42`	`43`	`}`
`43`	`44`
`44`		`-std::vector<HighScore> getFullScoreData(std::vector<std::string> highScores)`
	`45`	`+vector<HighScore> getFullScoreData(vector<string> highScores)`
`45`	`46`	`{`
`46`		`- std::vector<HighScore> scores;`
	`47`	`+ vector<HighScore> scores;`
`47`	`48`	`scores.reserve(9);`
`48`	`49`
`49`	`50`	`int rank = 1;`
`50`	`51`
`51`	`52`	`for (auto &highScore: highScores)`
`52`	`53`	`{`
`53`		`- std::string scoreString = extractLastNChars(highScore, 3);`
	`54`	`+ string scoreString = extractLastNChars(highScore, 3);`
`54`	`55`	`int score = stoi(scoreString);`
`55`	`56`
`56`		`- std::string nameString = highScore.substr(0, 3);`
	`57`	`+ string nameString = highScore.substr(0, 3);`
`57`	`58`
`58`	`59`	`scores.push_back({rank, nameString, score});`
`59`	`60`	`rank++;`
`@@ -62,24 +63,24 @@ std::vector<HighScore> getFullScoreData(std::vector<std::string> highScores)`
`62`	`63`	`return scores;`
`63`	`64`	`}`
`64`	`65`
`65`		`-std::vector<std::string> saveActualHighScores(std::vector<std::string> highScores, int actualScore, std::string playerName)`
	`66`	`+vector<string> saveActualHighScores(vector<string> highScores, int actualScore, string playerName)`
`66`	`67`	`{`
`67`		`- std::vector<std::string> actualScores;`
	`68`	`+ vector<string> actualScores;`
`68`	`69`	`actualScores.reserve(9);`
`69`	`70`
`70`	`71`	`bool actualScoreWasAdded = false;`
`71`	`72`
`72`	`73`	`for (size_t i = 0; i < highScores.size(); i++)`
`73`	`74`	`{`
`74`		`- std::string highScore = highScores[i];`
	`75`	`+ string highScore = highScores[i];`
`75`	`76`
`76`		`- std::string scoreString = extractLastNChars(highScore, 3);`
	`77`	`+ string scoreString = extractLastNChars(highScore, 3);`
`77`	`78`
`78`	`79`	`int score = stoi(scoreString);`
`79`	`80`
`80`	`81`	`if (!actualScoreWasAdded && actualScore > score)`
`81`	`82`	`{`
`82`		`- std::string fullScore = playerName + " " + std::to_string(actualScore);`
	`83`	`+ string fullScore = playerName + " " + std::to_string(actualScore);`
`83`	`84`	`actualScores.push_back(fullScore);`
`84`	`85`	`actualScoreWasAdded = true;`
`85`	`86`	`}`
`@@ -98,7 +99,7 @@ std::vector<std::string> saveActualHighScores(std::vector<std::string> highScore`
`98`	`99`	`//I can create a infinite loop and it will create a really big file and create a high ram consumption.`
`99`	`100`	`for (size_t i = 0; i < actualScores.size(); i++)`
`100`	`101`	`{`
`101`		`- std::string fullScoreString = actualScores[i];`
	`102`	`+ string fullScoreString = actualScores[i];`
`102`	`103`
`103`	`104`	`if (i == actualScores.size() - 1)`
`104`	`105`	`{`
`@@ -118,9 +119,9 @@ std::vector<std::string> saveActualHighScores(std::vector<std::string> highScore`
`118`	`119`	`return highScores;`
`119`	`120`	`}`
`120`	`121`
`121`		`-std::vector<std::string> loadHighScores()`
	`122`	`+vector<string> loadHighScores()`
`122`	`123`	`{`
`123`		`- std::vector<std::string> scores;`
	`124`	`+ vector<string> scores;`
`124`	`125`	`scores.reserve(9);`
`125`	`126`
`126`	`127`	`std::ifstream highScoresFile("assets/high-scores.txt");`
`@@ -130,7 +131,7 @@ std::vector<std::string> loadHighScores()`
`130`	`131`	`return saveInitialHighScores();`
`131`	`132`	`}`
`132`	`133`
`133`		`- for (std::string line; getline(highScoresFile, line);)`
	`134`	`+ for (string line; getline(highScoresFile, line);)`
`134`	`135`	`{`
`135`	`136`	`scores.push_back(line);`
`136`	`137`	`}`
`@@ -149,7 +150,7 @@ void saveScore(int score)`
`149`	`150`	`highScoreFile.close();`
`150`	`151`	`}`
`151`	`152`
`152`		`-void savePlayerName(std::string playerName)`
	`153`	`+void savePlayerName(string playerName)`
`153`	`154`	`{`
`154`	`155`	`std::ofstream playerNameFile("assets/player.txt");`
`155`	`156`
`@@ -158,9 +159,9 @@ void savePlayerName(std::string playerName)`
`158`	`159`	`playerNameFile.close();`
`159`	`160`	`}`
`160`	`161`
`161`		`-std::string loadPlayerName()`
	`162`	`+string loadPlayerName()`
`162`	`163`	`{`
`163`		`- std::string playerName;`
	`164`	`+ string playerName;`
`164`	`165`
`165`	`166`	`std::ifstream playerNameFile("assets/player.txt");`
`166`	`167`
`@@ -179,7 +180,7 @@ std::string loadPlayerName()`
`179`	`180`
`180`	`181`	`int loadHighScore()`
`181`	`182`	`{`
`182`		`- std::string highScoreText;`
	`183`	`+ string highScoreText;`
`183`	`184`
`184`	`185`	`std::ifstream highScoreFile("assets/high-score.txt");`
`185`	`186`