ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Save more detailed informations about reverse mode in GP highscores (#4616)

Browse Source
This commit is contained in:
Kuba
2021-09-14 10:22:29 +02:00
committed by GitHub
parent c4fdf9c8ac
commit 0b5eda8ef9
10 changed files with 139 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/modes/world.cpp
View File

@@ -1271,13 +1271,10 @@ Highscores* World::getHighscores() const
// ---------------------------------------------------------------------------
Highscores* World::getGPHighscores() const
{
const Highscores::HighscoreType type = "HST_GRANDPRIX";
Highscores* highscores = highscore_manager->getHighscores(type,
RaceManager::get()->getNumNonGhostKarts(),
RaceManager::get()->getDifficulty(),
RaceManager::get()->getGrandPrix().getId(),
0,
RaceManager::get()->getGrandPrix().getReverseType() == GrandPrixData::GP_ALL_REVERSE);
Highscores* highscores = highscore_manager->getGPHighscores(RaceManager::get()->getNumNonGhostKarts(),
RaceManager::get()->getDifficulty(),
RaceManager::get()->getGrandPrix().getId(),
RaceManager::get()->getGrandPrix().getReverseType());
return highscores;
}

18
src/race/grand_prix_data.cpp
View File

@@ -629,5 +629,23 @@ irr::core::stringw GrandPrixData::getName() const
{
return m_editable ? m_name.c_str() : _(m_name.c_str());
}
// ----------------------------------------------------------------------------
irr::core::stringw GrandPrixData::reverseTypeToString(GPReverseType reverse_type)
{
switch (reverse_type)
{
case GrandPrixData::GP_DEFAULT_REVERSE:
return _("Default");
case GrandPrixData::GP_NO_REVERSE:
return _("None");
case GrandPrixData::GP_ALL_REVERSE:
return _("All");
case GrandPrixData::GP_RANDOM_REVERSE:
return _("Random");
default:
return "N/A";
}
return "N/A";
}
/* EOF */

1
src/race/grand_prix_data.hpp
View File

@@ -169,6 +169,7 @@ public:
const { return m_reverse_type; }
static const char* getRandomGPID() { return "random"; }
static irr::core::stringw getRandomGPName();
static irr::core::stringw reverseTypeToString(GPReverseType reverse_type);
}; // GrandPrixData
#endif

24
src/race/highscore_manager.cpp
View File

@@ -201,3 +201,27 @@ Highscores* HighscoreManager::getHighscores(const Highscores::HighscoreType &hig
m_all_scores.push_back(std::unique_ptr<Highscores>(highscores));
return highscores;
} // getHighscores
// -----------------------------------------------------------------------------
Highscores* HighscoreManager::getGPHighscores(int num_karts,
const RaceManager::Difficulty difficulty,
const std::string &trackName,
GrandPrixData::GPReverseType reverse_type)
{
Highscores *highscores = 0;
// See if we already have a record for this type
for (auto& hs : m_all_scores)
{
if (hs->matches(num_karts, difficulty, trackName, reverse_type))
{
// we found one entry for this kind of race, return it
return hs.get();
}
} // for i in m_all_scores
// we don't have an entry for such a race currently. Create one.
highscores = new Highscores(num_karts, difficulty,
trackName, reverse_type);
m_all_scores.push_back(std::unique_ptr<Highscores>(highscores));
return highscores;
} // get

6
src/race/highscore_manager.hpp
View File

@@ -59,6 +59,12 @@ public:
const int number_of_laps,
const bool reverse);
// ------------------------------------------------------------------------
/** getHighscores method for grandprix highscores */
Highscores *getGPHighscores(int num_karts,
const RaceManager::Difficulty difficulty,
const std::string &trackName,
GrandPrixData::GPReverseType reverse_type);
// ------------------------------------------------------------------------
void deleteHighscores(int i) { m_all_scores.erase
(m_all_scores.begin() + i); }
// ------------------------------------------------------------------------

57
src/race/highscores.cpp
View File

@@ -44,6 +44,27 @@ Highscores::Highscores(const HighscoreType &highscore_type,
m_difficulty = difficulty;
m_number_of_laps = number_of_laps;
m_reverse = reverse;
m_gp_reverse_type = (int)GrandPrixData::GP_DEFAULT_REVERSE;
for(int i=0; i<HIGHSCORE_LEN; i++)
{
m_name[i] = "";
m_kart_name[i] = "";
m_time[i] = -9.9f;
}
}
// ----------------------------------------------------------------------------
Highscores::Highscores(int num_karts, const RaceManager::Difficulty &difficulty,
const std::string &track_name,
const GrandPrixData::GPReverseType reverse_type)
{
m_track = track_name;
m_highscore_type = "HST_GRANDPRIX";
m_number_of_karts = num_karts;
m_difficulty = difficulty;
m_number_of_laps = 0;
m_reverse = false;
m_gp_reverse_type = reverse_type;
for(int i=0; i<HIGHSCORE_LEN; i++)
{
@@ -61,6 +82,7 @@ Highscores::Highscores(const XMLNode &node)
m_difficulty = -1;
m_number_of_laps = 0;
m_reverse = false;
m_gp_reverse_type = (int)GrandPrixData::GP_DEFAULT_REVERSE;
for(int i=0; i<HIGHSCORE_LEN; i++)
{
@@ -81,9 +103,16 @@ void Highscores::readEntry(const XMLNode &node)
node.get("hscore-type", &hst );
m_highscore_type = (HighscoreType)hst;
node.get("difficulty", &m_difficulty );
node.get("number-of-laps", &m_number_of_laps );
node.get("reverse", &m_reverse );
if (hst == "HST_GRANDPRIX")
{
m_number_of_laps = 0;
node.get("reverse-type", &m_gp_reverse_type);
}
else
{
node.get("number-of-laps", &m_number_of_laps);
node.get("reverse", &m_reverse);
}
for(unsigned int i=0; i<node.getNumNodes(); i++)
{
if (i >= HIGHSCORE_LEN)
@@ -128,8 +157,12 @@ void Highscores::writeEntry(UTFWriter &writer)
writer << " number-karts =\"" << m_number_of_karts << "\"\n";
writer << " difficulty =\"" << m_difficulty << "\"\n";
writer << " hscore-type =\"" << m_highscore_type.c_str() << "\"\n";
writer << " number-of-laps=\"" << m_number_of_laps << "\"\n";
writer << " reverse =\"" << m_reverse << "\">\n";
if (m_highscore_type != "HST_GRANDPRIX")
writer << " number-of-laps=\"" << m_number_of_laps << "\"\n";
if (m_highscore_type == "HST_GRANDPRIX")
writer << " reverse-type=\"" << m_gp_reverse_type << "\">\n";
else
writer << " reverse =\"" << m_reverse << "\">\n";
for(int i=0; i<HIGHSCORE_LEN; i++)
{
@@ -158,6 +191,18 @@ int Highscores::matches(const HighscoreType &highscore_type,
m_number_of_karts == num_karts &&
m_reverse == reverse );
} // matches
// -----------------------------------------------------------------------------
int Highscores::matches(int num_karts,
const RaceManager::Difficulty &difficulty,
const std::string &track,
const GrandPrixData::GPReverseType reverse_type)
{
return (m_highscore_type == "HST_GRANDPRIX" &&
m_track == track &&
m_difficulty == difficulty &&
m_number_of_karts == num_karts &&
m_gp_reverse_type == reverse_type );
}
int Highscores::findHighscorePosition(const std::string& kart_name,
const core::stringw& name, const float time)
@@ -223,7 +268,7 @@ int Highscores::addGPData(const std::string& kart_name,
m_number_of_karts = RaceManager::get()->getNumNonGhostKarts();
m_difficulty = RaceManager::get()->getDifficulty();
m_number_of_laps = 0;
m_reverse = RaceManager::get()->getReverseTrack();
m_gp_reverse_type = RaceManager::get()->getGrandPrix().getReverseType();
m_name[position] = name;
m_time[position] = time;
m_kart_name[position] = kart_name;

11
src/race/highscores.hpp
View File

@@ -60,6 +60,7 @@ public:
int m_difficulty;
int m_number_of_laps;
bool m_reverse;
int m_gp_reverse_type;
private:
std::array<std::string, HIGHSCORE_LEN> m_kart_name;
@@ -81,6 +82,10 @@ public:
int num_karts, const RaceManager::Difficulty &difficulty,
const std::string &trackName, const int number_of_laps,
const bool reverse);
/** Constructor for grandprix highscores */
Highscores (int num_karts, const RaceManager::Difficulty &difficulty,
const std::string &trackName,
const GrandPrixData::GPReverseType reverse_type);
/** Creates an entry from a file
*/
Highscores (const XMLNode &node);
@@ -94,6 +99,12 @@ public:
const std::string &track, const int number_of_laps,
const bool reverse);
// ------------------------------------------------------------------------
/** matches method for grandprix highscores */
int matches(int num_karts,
const RaceManager::Difficulty &difficulty,
const std::string &track,
const GrandPrixData::GPReverseType reverse_type);
// ------------------------------------------------------------------------
int addData (const std::string& kart_name,
const irr::core::stringw& name, const float time);
int addGPData (const std::string& kart_name,

14
src/states_screens/dialogs/high_score_info_dialog.cpp
View File

@@ -126,9 +126,17 @@ HighScoreInfoDialog::HighScoreInfoDialog(Highscores* highscore, bool is_linear,
m_num_laps_label->setVisible(true);
m_num_laps_label->setText(_("Laps: %d", m_hs->m_number_of_laps), true);
}
stringw is_reverse = m_hs->m_reverse ? _("Yes") : _("No");
m_reverse_label->setVisible(true);
m_reverse_label->setText(_("Reverse: %s", is_reverse), true);
stringw is_reverse;
if (m_major_mode == RaceManager::MAJOR_MODE_GRAND_PRIX)
{
is_reverse = GrandPrixData::reverseTypeToString((GrandPrixData::GPReverseType)m_hs->m_gp_reverse_type);
}
else
{
is_reverse = m_hs->m_reverse ? _("Yes") : _("No");
}
m_reverse_label->setVisible(true);
m_reverse_label->setText(_("Reverse: %s", is_reverse), true);
}
else
{

11
src/states_screens/gp_info_screen.cpp
View File

@@ -468,12 +468,11 @@ void GPInfoScreen::updateHighscores()
if(m_gp.isRandomGP())
return;
const Highscores::HighscoreType type = "HST_GRANDPRIX";
Highscores* highscores = highscore_manager->getHighscores(type,
RaceManager::get()->getNumberOfKarts(),
RaceManager::get()->getDifficulty(),
m_gp.getId(),
0,
getReverse() == GrandPrixData::GP_ALL_REVERSE);
Highscores* highscores = highscore_manager->getGPHighscores(
RaceManager::get()->getNumberOfKarts(),
RaceManager::get()->getDifficulty(),
m_gp.getId(),
getReverse());
m_highscore_list->clear();
int count = highscores->getNumberEntries();
std::string kart;

8
src/states_screens/high_score_selection.cpp
View File

@@ -242,8 +242,16 @@ void HighScoreSelection::loadList()
row.push_back(GUIEngine::ListWidget::ListCell
(StringUtils::toWString(hs->m_number_of_laps), -1, 3, true));
}
if (m_major_mode == RaceManager::MAJOR_MODE_GRAND_PRIX)
{
row.push_back(GUIEngine::ListWidget::ListCell(
GrandPrixData::reverseTypeToString((GrandPrixData::GPReverseType)hs->m_gp_reverse_type), -1, 3, true));
}
else
{
row.push_back(GUIEngine::ListWidget::ListCell
(hs->m_reverse ? _("Yes") : _("No"), -1, 3, true));
}
}
m_high_scores_list_widget->addItem(StringUtils::toString(i), row);
}