Skip to content

Commit d841efc

Browse files
abb2kabb2k
committed
organization
1 parent f9c5733 commit d841efc

7 files changed

Lines changed: 578 additions & 554 deletions

File tree

‎src/hooks/DTPlayLayer.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -28,12 +28,12 @@ bool DTPlayLayer::init(GJGameLevel* level, bool p1, bool p2) {
2828
if (!PlayLayer::init(level, p1, p2)) return false;
2929

3030
auto metaRes = StatsManager::getMetadata(level);
31-
if (metaRes.isErr() && metaRes.unwrapErr().size() && metaRes.unwrapErr()[0] == '1'){
31+
if (metaRes.isErr() && metaRes.unwrapErr().code == 1){
3232
LevelMetadeta newMeta{};
3333
metaRes = Ok(newMeta);
3434
}
3535
else if (metaRes.isErr()){
36-
geode::Notification::create(fmt::format("Failed to load DT level data! {}", metaRes.unwrapErr()), NotificationIcon::Error)->show();
36+
geode::Notification::create(fmt::format("Failed to load DT level data! {}", metaRes.unwrapErr().error), NotificationIcon::Error)->show();
3737
}
3838

3939
if (metaRes.isOk()){
@@ -448,7 +448,7 @@ void DTPlayLayer::checkDelta(float delta) {
448448
m_fields->gameTimeHistory.pop_front();
449449
}
450450

451-
if (m_fields->realTimeHistory.size() >= 30) {
451+
if (m_fields->realTimeHistory.size() >= 30 && m_fields->rollingGameSum != 0) {
452452
auto currentRatio = m_fields->rollingGameSum / m_fields->rollingRealSum;
453453
auto expectedRatio = m_fields->currentTimeWarp;
454454

‎src/managers/StatsManager.cpp‎

Lines changed: 37 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,8 @@
88
using namespace geode::prelude;
99

1010
std::vector<std::string> StatsManager::splitStr(const std::string& str, const std::string& delim) {
11+
if (delim.empty()) return {};
12+
1113
size_t posStart = 0;
1214
size_t posEnd;
1315
size_t delimLen = delim.length();
@@ -116,90 +118,96 @@ std::array<std::string, 62> StatsManager::m_AllFontsMap{
116118
/* main functions
117119
================== */
118120

119-
Result<LevelMetadeta> StatsManager::getMetadata(GJGameLevel* const level){
121+
Result<LevelMetadeta, ErrorWithCode> StatsManager::getMetadata(GJGameLevel* const level){
120122
GEODE_UNWRAP_INTO(auto levelKey, StatsManager::getLevelKey(level));
121123
return getMetadata(levelKey);
122124
}
123-
Result<LevelMetadeta> StatsManager::getMetadata(const std::string& levelKey){
125+
Result<LevelMetadeta, ErrorWithCode> StatsManager::getMetadata(const std::string& levelKey){
124126
return getMetadata(getSavesFolderPath() / levelKey);
125127
}
126128

127-
Result<LevelMetadeta> StatsManager::getMetadata(const std::filesystem::path& path){
129+
Result<LevelMetadeta, ErrorWithCode> StatsManager::getMetadata(const std::filesystem::path& path){
128130
auto levelSaveFilePath = path / StatsManager::METADATA_FILE_NAME;
129131

130132
if (!std::filesystem::exists(levelSaveFilePath))
131-
return Err("1 (no stats exist for level!)");
133+
return Err(ErrorWithCode("no stats exist for level!", 1));
132134

133-
GEODE_UNWRAP_INTO(auto json, file::readJson(levelSaveFilePath));
135+
auto readRes = file::readJson(levelSaveFilePath);
136+
if (readRes.isErr()) return Err("Metadata Corrupted");
137+
auto json = readRes.unwrap().as<LevelMetadeta>();
138+
if (json.isErr()) return Err("Metadata Corrupted");
134139

135-
return json.as<LevelMetadeta>();
140+
return Ok(json.unwrap());
136141
}
137142

138-
Result<Session> StatsManager::getSession(GJGameLevel* const level, long long sessionTime){
143+
Result<Session, ErrorWithCode> StatsManager::getSession(GJGameLevel* const level, long long sessionTime){
139144
GEODE_UNWRAP_INTO(auto levelKey, StatsManager::getLevelKey(level));
140145
return getSession(levelKey, sessionTime);
141146
}
142-
Result<Session> StatsManager::getSession(const std::string& levelKey, long long sessionTime){
147+
Result<Session, ErrorWithCode> StatsManager::getSession(const std::string& levelKey, long long sessionTime){
143148
return getSession(getSavesFolderPath() / levelKey, sessionTime);
144149
}
145150

146-
Result<Session> StatsManager::getSession(const std::filesystem::path& path, long long sessionTime){
151+
Result<Session, ErrorWithCode> StatsManager::getSession(const std::filesystem::path& path, long long sessionTime){
147152
auto levelSaveFilePath = path / StatsManager::SESSIONS_DIR_NAME / (std::to_string(sessionTime) + ".dt");
148153

149154
if (!std::filesystem::exists(levelSaveFilePath))
150-
return Err("1 (no stats exist for level!)");
155+
return Err(ErrorWithCode("no stats exist for level!", 1));
151156

152157
auto sessionRes = file::readJson(levelSaveFilePath);
153158
if (sessionRes.isErr()) return Err("Session Corrupted");
154159
auto session = sessionRes.unwrap().as<Session>();
155160
if (session.isErr()) return Err("Session Corrupted");
156161

157-
return session;
162+
return Ok(session.unwrap());
158163
}
159164

160-
Result<GeneralData> StatsManager::getGeneral(GJGameLevel* const level){
165+
Result<GeneralData, ErrorWithCode> StatsManager::getGeneral(GJGameLevel* const level){
161166
GEODE_UNWRAP_INTO(auto levelKey, StatsManager::getLevelKey(level));
162167
return getGeneral(levelKey);
163168
}
164-
Result<GeneralData> StatsManager::getGeneral(const std::string& levelKey){
169+
Result<GeneralData, ErrorWithCode> StatsManager::getGeneral(const std::string& levelKey){
165170
return getGeneral(getSavesFolderPath() / levelKey);
166171
}
167172

168-
Result<GeneralData> StatsManager::getGeneral(const std::filesystem::path& path){
173+
Result<GeneralData, ErrorWithCode> StatsManager::getGeneral(const std::filesystem::path& path){
169174
auto levelSaveFilePath = path / StatsManager::FROM0_FILE_NAME;
170175

171176
if (!std::filesystem::exists(levelSaveFilePath) || std::filesystem::is_empty(levelSaveFilePath))
172-
return Err("1(no stats exist for level!)");
177+
return Err(ErrorWithCode("no stats exist for level!", 1));
173178

174179
auto jsonRes = file::readJson(levelSaveFilePath);
175180
if (jsonRes.isErr()) return Err("Save Corrupted");
176181
auto genDataRes = jsonRes.unwrap().as<GeneralData>();
177182
if (genDataRes.isErr()) return Err("Save Corrupted");
178183

179-
return genDataRes;
184+
return Ok(genDataRes.unwrap());
180185
}
181186

182-
Result<LevelData> StatsManager::getLevelData(GJGameLevel* const level){
187+
Result<LevelData, ErrorWithCode> StatsManager::getLevelData(GJGameLevel* const level){
183188
GEODE_UNWRAP_INTO(auto levelKey, StatsManager::getLevelKey(level));
184189

185190
return getLevelData(levelKey);
186191
}
187-
Result<LevelData> StatsManager::getLevelData(const std::string& levelKey){
192+
Result<LevelData, ErrorWithCode> StatsManager::getLevelData(const std::string& levelKey){
188193
LevelData data;
194+
189195
GEODE_UNWRAP_INTO(data.metadata, StatsManager::getMetadata(levelKey));
196+
190197
data.from0 = StatsManager::getGeneral(levelKey);
191198
data.sessionNames = StatsManager::getAllSessionTimesForLevel(levelKey);
192199
data.levelKey = levelKey;
193200

194201
return Ok(data);
195202
}
196203

197-
Result<LevelData> StatsManager::getLevelData(const std::filesystem::path& path){
204+
Result<LevelData, ErrorWithCode> StatsManager::getLevelData(const std::filesystem::path& path){
198205
LevelData data;
206+
199207
GEODE_UNWRAP_INTO(data.metadata, StatsManager::getMetadata(path));
208+
200209
data.from0 = StatsManager::getGeneral(path);
201210
data.sessionNames = StatsManager::getAllSessionTimesForLevel(path);
202-
data.levelKey = data.levelKey;
203211

204212
return Ok(data);
205213
}
@@ -327,7 +335,7 @@ Result<> StatsManager::addBackup(const std::string& levelKey, bool saveLevelStat
327335
//log::info("adding backup for level {} | {} | {}", levelKey, saveLevelStats, sessionsToSave);
328336
std::error_code ec;
329337
auto metaRes = getMetadata(levelKey);
330-
if (metaRes.isErr()) return Err("No level to back up! {}", metaRes.unwrapErr());
338+
if (metaRes.isErr()) return Err("No level to back up! {}", metaRes.unwrapErr().error);
331339
auto metadata = metaRes.unwrap();
332340

333341
createFilesIfNeeded(levelKey);
@@ -460,23 +468,23 @@ void StatsManager::setCurrentLevel(GJGameLevel* const& level){
460468
currentFrom0 = std::nullopt;
461469
currentSession = std::nullopt;
462470
currentMetadata = std::nullopt;
463-
log::error("Failed to apply current level stats as main stats ({})", metadataRes.unwrapErr());
471+
log::error("Failed to apply current level stats as main stats ({})", metadataRes.unwrapErr().error);
464472
return;
465473
}
466474

467475
if (from0Res.isErr()){
468-
if (from0Res.unwrapErr()[0] == '1'){
476+
if (from0Res.unwrapErr().code == 1){
469477
auto newF0 = GeneralData{.currentBest = -1};
470478

471479
from0Res = Ok(newF0);
472480
}
473481
else{
474-
from0Res = Err("-");
482+
from0Res = Err(ErrorWithCode("", 3));
475483
currentFrom0 = std::nullopt;
476484
}
477485
}
478486

479-
if (!(from0Res.isErr() && from0Res.unwrapErr() == "-"))
487+
if (!(from0Res.isErr() && from0Res.unwrapErr().code == 3))
480488
currentFrom0 = from0Res.unwrap();
481489

482490
currentMetadata = metadataRes.unwrap();
@@ -552,7 +560,7 @@ void StatsManager::logDeaths(const std::vector<int>& percents) {
552560

553561
void StatsManager::logRun(const Run& run, bool instantSave) {
554562
if (currentLevel == nullptr || !run.start.has_value()) {
555-
log::error("Failed to log deaths");
563+
log::error("Failed to log run");
556564
return;
557565
}
558566

@@ -596,7 +604,6 @@ void StatsManager::logRuns(const std::vector<Run>& runs) {
596604
return;
597605
}
598606

599-
bool TrackRun = false;
600607
for (int i = 0; i < runs.size(); i++)
601608
{
602609
logRun(runs[i], false);
@@ -895,12 +902,12 @@ Result<std::vector<std::pair<std::string, LevelMetadeta>>> StatsManager::getAllL
895902
for (int i = 0; i < allLevels.size(); i++)
896903
{
897904
if (std::filesystem::is_directory(allLevels[i])){
898-
auto currentDirName = geode::utils::string::pathToString(allLevels[i].parent_path());
905+
auto currentDirName = geode::utils::string::pathToString(allLevels[i].filename());
899906
// log::info("Getting level stats for level: {}", currentDirName);
900907

901908
auto currentLevel = StatsManager::getMetadata(currentDirName);
902909
if (currentLevel.isErr()){
903-
Notification::create(fmt::format("failed getting some levels, errors send in logs.", currentDirName, currentLevel.unwrapErr()), nullptr)->show();
910+
Notification::create(fmt::format("failed getting some levels, errors send in logs.", currentDirName, currentLevel.unwrapErr().error), nullptr)->show();
904911
failedKeys.push_back(currentDirName);
905912
continue;
906913
}
@@ -962,10 +969,6 @@ int StatsManager::getDifficulty(GJGameLevel* const& level){
962969
return 0;
963970
}
964971

965-
void StatsManager::setPath(const std::filesystem::path& path){
966-
getSavesFolderPath() = path;
967-
}
968-
969972
int StatsManager::getCursorPosition(CCLabelBMFont* const& text, CCLabelBMFont* const& cursor){
970973
if (text->getString() == nullptr) return -1;
971974
if (text->getString()[0] == '\0') return -1;
@@ -1236,7 +1239,7 @@ bool StatsManager::transferPlaytimeFromPT(GJGameLevel* level){
12361239
return transferPlaytimeFromPT(data, level);
12371240
}
12381241

1239-
bool StatsManager::transferPlaytimeFromPT(geode::Result<LevelData>& data, GJGameLevel* level){
1242+
bool StatsManager::transferPlaytimeFromPT(geode::Result<LevelData, ErrorWithCode>& data, GJGameLevel* level){
12401243
std::string lvlID = level->m_levelType == GJLevelType::Editor ? fmt::format("Editor-{}", EditorIDs::getID(level)) : std::to_string(level->m_levelID.value());
12411244
auto ptPath = Mod::get()->getSaveDir().parent_path() / "nanew.playtime-tracker" / "data" / (lvlID + ".json");
12421245

‎src/managers/StatsManager.hpp‎

Lines changed: 13 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -39,18 +39,18 @@ class StatsManager {
3939

4040
#pragma region level setters/getters
4141

42-
static Result<LevelMetadeta> getMetadata(GJGameLevel* const level);
43-
static Result<LevelMetadeta> getMetadata(const std::string& levelKey);
44-
static Result<LevelMetadeta> getMetadata(const std::filesystem::path& path);
45-
static Result<Session> getSession(GJGameLevel* const level, long long sessionTime);
46-
static Result<Session> getSession(const std::string& levelKey, long long sessionTime);
47-
static Result<Session> getSession(const std::filesystem::path& path, long long sessionTime);
48-
static Result<GeneralData> getGeneral(GJGameLevel* const level);
49-
static Result<GeneralData> getGeneral(const std::string& levelKey);
50-
static Result<GeneralData> getGeneral(const std::filesystem::path& path);
51-
static Result<LevelData> getLevelData(GJGameLevel* const level);
52-
static Result<LevelData> getLevelData(const std::string& levelKey);
53-
static Result<LevelData> getLevelData(const std::filesystem::path& path);
42+
static Result<LevelMetadeta, ErrorWithCode> getMetadata(GJGameLevel* const level);
43+
static Result<LevelMetadeta, ErrorWithCode> getMetadata(const std::string& levelKey);
44+
static Result<LevelMetadeta, ErrorWithCode> getMetadata(const std::filesystem::path& path);
45+
static Result<Session, ErrorWithCode> getSession(GJGameLevel* const level, long long sessionTime);
46+
static Result<Session, ErrorWithCode> getSession(const std::string& levelKey, long long sessionTime);
47+
static Result<Session, ErrorWithCode> getSession(const std::filesystem::path& path, long long sessionTime);
48+
static Result<GeneralData, ErrorWithCode> getGeneral(GJGameLevel* const level);
49+
static Result<GeneralData, ErrorWithCode> getGeneral(const std::string& levelKey);
50+
static Result<GeneralData, ErrorWithCode> getGeneral(const std::filesystem::path& path);
51+
static Result<LevelData, ErrorWithCode> getLevelData(GJGameLevel* const level);
52+
static Result<LevelData, ErrorWithCode> getLevelData(const std::string& levelKey);
53+
static Result<LevelData, ErrorWithCode> getLevelData(const std::filesystem::path& path);
5454
static Result<BackupLevelData> getBackupData(const std::string& levelKey, long long backupName);
5555

5656
static Result<> setMetadata(const LevelMetadeta& stats, GJGameLevel* const level);
@@ -133,9 +133,6 @@ class StatsManager {
133133
// 7 = Easy Demon, 8 = Medium Demon, 9 = Insane Demon, 10 = Extreme Demon
134134
static int getDifficulty(GJGameLevel* const& level);
135135

136-
//sets the current deaths save folder path
137-
static void setPath(const std::filesystem::path& path);
138-
139136
// return a splitted version of the string provided, devided by the delim
140137
static std::vector<std::string> splitStr(const std::string& str, const std::string& delim);
141138

@@ -157,7 +154,7 @@ class StatsManager {
157154
static void mergeMapsAdd(std::map<K, V>& target, const std::map<K, V>& source);
158155

159156
static bool transferPlaytimeFromPT(GJGameLevel* level);
160-
static bool transferPlaytimeFromPT(geode::Result<LevelData>& data, GJGameLevel* level);
157+
static bool transferPlaytimeFromPT(geode::Result<LevelData, ErrorWithCode>& data, GJGameLevel* level);
161158
};
162159

163160
template<typename K, typename V>

‎src/nodes/layers/DTLayer.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1002,7 +1002,7 @@ void DTLayer::UpdateSharedStats(){
10021002

10031003
auto currStatsRes = StatsManager::getLevelData(linkedLevel);
10041004
if (currStatsRes.isErr()){
1005-
Notification::create(fmt::format("failed to get data for linked level - {} | {}", linkedLevel, currStatsRes.unwrapErr()))->show();
1005+
Notification::create(fmt::format("failed to get data for linked level - {} | {}", linkedLevel, currStatsRes.unwrapErr().error))->show();
10061006
continue;
10071007
}
10081008
auto currStats = currStatsRes.unwrap();
@@ -2803,7 +2803,7 @@ Result<Session, UpdateFutureError> DTLayer::loadSessionFromSave(std::optional<in
28032803
{
28042804
auto sessionRes = StatsManager::getSession(lvlKey, SDate);
28052805
if (sessionRes.isErr()){
2806-
sess = Err(sessionRes.unwrapErr());
2806+
sess = Err(sessionRes.unwrapErr().error);
28072807
break;
28082808
}
28092809

@@ -3401,13 +3401,13 @@ void DTLayer::onGroupSelected(int const& id){
34013401

34023402
void DTLayer::CleanGetStats(){
34033403
m_MyLevelStats = StatsManager::getLevelData(m_Level);
3404-
if (m_MyLevelStats.isErr() && m_MyLevelStats.unwrapErr().size() && m_MyLevelStats.unwrapErr()[0] == '1'){
3404+
if (m_MyLevelStats.isErr() && m_MyLevelStats.unwrapErr().code == 1){
34053405
LevelData newData;
34063406
newData.levelKey = StatsManager::getLevelKey(m_Level).unwrap();
34073407
m_MyLevelStats = Ok(newData);
34083408
}
34093409
else if (m_MyLevelStats.isErr()){
3410-
auto notif = geode::Notification::create(fmt::format("Failed to load DT level data! {}", m_MyLevelStats.unwrapErr()), NotificationIcon::Error, 3);
3410+
auto notif = geode::Notification::create(fmt::format("Failed to load DT level data! {}", m_MyLevelStats.unwrapErr().error), NotificationIcon::Error, 3);
34113411
notif->show();
34123412
notif->setZOrder(101);
34133413
}

‎src/nodes/layers/DTLayer.hpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ class DTLayer : public Popup, public FLAlertLayerProtocol {
3838

3939
GJGameLevel* m_Level;
4040

41-
Result<LevelData> m_MyLevelStats = Err("");
41+
Result<LevelData, ErrorWithCode> m_MyLevelStats = Err("");
4242
std::vector<LevelData> linkedLevelsData{};
4343
SessionCategory sessionsOrder{};
4444
SessionCategory daySGroup{};
@@ -126,10 +126,10 @@ class DTLayer : public Popup, public FLAlertLayerProtocol {
126126
auto myStats = m_MyLevelStats.unwrap();
127127
if (myStats.from0.isErr()){
128128
auto error = myStats.from0.unwrapErr();
129-
if (error[0] == '1')
129+
if (error.code == 1)
130130
co_return Err(UpdateFutureError("No Deaths Saved!", false));
131131
else
132-
co_return Err(error);
132+
co_return Err(error.error);
133133
}
134134
auto myFrom0Stats = myStats.from0.unwrap();
135135
auto linkedLevelsCopy = linkedLevelsData;

0 commit comments

Comments
 (0)