Use implicit MaxLevel (based on highest level seen)

Author: ephphatha

Packaging/resources/assets/txtdata/Readme.md

@@ -76,36 +76,25 @@ base 10 with no decimal or thousands separators. The first row of this file is
 used as a header and requires the following column names:
 
 #### Level
-A numeric value used to set the order for remaining values, or the special
-`MaxLevel` value which is used to determine the maximum character level. The
-header line MUST be the first line in the file. The `MaxLevel` line MUST be
-present, it SHOULD be the second line but can appear later in the file. Levels
-SHOULD proceed in ascending order after that. If you leave any gaps then
-characters will not be able to advance past that level and experience caps
-will not apply.
-
-For example you could set a maximum level of 36 by changing the MaxLevel value:
-```tsv
-Level	Experience
-MaxLevel	36
-0	0
-1	2000
-...
-```
+A numeric value used to set the order for experience thresholds. The header
+line MUST be the first line in the file. Levels SHOULD proceed in ascending
+order after that. Levels up to 255 are supported, the highest value will be
+used as the maximum character level. If you leave any gaps then characters
+will not be able to advance past that level and experience caps will not apply.
+
+If you're familiar with Diablo 2 text files you might expect to use a MaxLevel
+row to set character level limits, these lines are ignored and the largest
+Level value is used as described above.
 
-The first row following the `MaxLevel` line SHOULD be `0	0` (as all characters
-start at level 1, we ignore these values and use the threshold for level 1 to
-determine when characters advance past level 1). There should also be at least
-as many rows as the highest value provided for `MaxLevel`. If you specify a
-`MaxLevel` of `60` but only provide experience values up to `50` then
-characters will level up to `51` but no further.
+The first row SHOULD be `0	0` (as all characters start at level 1, we ignore
+these values and use the threshold for level 1 to determine when characters
+advance past level 1).
 
 #### Experience
 This column determines the experience points required for characters to
 advance past that level. For example a file like:
 ```tsv
 Level	Experience
-MaxLevel	5
 0	0
 1	2000
 2	4000
@@ -121,9 +110,9 @@ points and will not level up any further.
 
 You should provide a value for every row up to (and including) the maximum
 level you intend players to be able to reach. If you have an empty cell for an
-experience value at a row earlier than the `MaxLevel` value then characters
-will not be able to advance past that level. They will continue to gain
-experience without a cap (up to the hard limit of `2^32-1`, 4,294,967,295).
+experience value at a given level then characters will not be able to advance
+past that level. They will continue to gain experience without a cap (up to the
+hard limit of `2^32-1`, 4,294,967,295).
 
 [d2-excel-plus]: https://github.com/Cjreek/D2ExcelPlus
 [d2mods-info]: https://www.d2mods.info/forum/viewtopic.php?t=34455

Source/playerdat.cpp

@@ -26,7 +26,7 @@ namespace devilution {
 
 namespace {
 
-struct ExperienceData {
+class ExperienceData {
 	/** Specifies the experience point limit of each level. The given values are defaults used if the data file is missing. */
 	std::vector<uint32_t> levelThresholds {
 		0,
@@ -82,12 +82,32 @@ struct ExperienceData {
 		1583495809
 	};
 
-	static constexpr uint8_t DefaultMaxLevel = 50;
-	uint8_t maxLevel = DefaultMaxLevel;
+public:
+	uint8_t getMaxLevel() const
+	{
+		if (levelThresholds.empty())
+			return 0;
+		return static_cast<uint8_t>(std::min<size_t>(levelThresholds.size() - 1, std::numeric_limits<uint8_t>::max()));
+	}
+
+	DVL_REINITIALIZES void clear()
+	{
+		levelThresholds.clear();
+	}
 
-	[[nodiscard]] uint32_t getThresholdForLevel(unsigned level)
+	[[nodiscard]] uint32_t getThresholdForLevel(unsigned level) const
 	{
-		return levelThresholds[std::min<size_t>({ level, maxLevel, levelThresholds.size() - 1 })];
+		return levelThresholds[std::min<size_t>(level, getMaxLevel())];
+	}
+
+	void setThresholdForLevel(unsigned level, uint32_t experience)
+	{
+		if (level >= levelThresholds.size()) {
+			// To avoid ValidatePlayer() resetting players to 0 experience we need to use the maximum possible value here
+			// As long as the file has no gaps it'll get initialised properly.
+			levelThresholds.resize(static_cast<size_t>(level) + 1, std::numeric_limits<uint32_t>::max());
+		}
+		levelThresholds[level] = experience;
 	}
 } ExperienceData;
 
@@ -190,12 +210,11 @@ void ReloadExperienceData()
 		return;
 	}
 
-	ExperienceData.levelThresholds.clear();
-	bool foundMaxLevelRecord = false;
+	ExperienceData.clear();
 	do {
 		uint8_t level = 0;
 		uint32_t experience = 0;
-		bool isMaxLevelRecord = false;
+		bool skipRecord = false;
 		for (auto &column : columns) {
 			result = DiscardMultipleFields(result.next, dataFile.end(), column.skipLength);
 
@@ -208,11 +227,11 @@ void ReloadExperienceData()
 			switch (column.type) {
 			case ExperienceColumnDefinition::ColumnType::Level: {
 				auto fromCharsResult = std::from_chars(result.next, dataFile.end(), level);
-				if (fromCharsResult.ec == std::errc::invalid_argument && !foundMaxLevelRecord) {
+				if (fromCharsResult.ec == std::errc::invalid_argument) {
 					// not a signless numeric value, is this the MaxLevel line?
 					result = GetNextField(fromCharsResult.ptr, dataFile.end());
 					if (result.value == "MaxLevel") {
-						isMaxLevelRecord = true;
+						skipRecord = true;
 					}
 					// else it was an invalid value, TODO: let the player know the data file contains errors
 				} else {
@@ -238,28 +257,16 @@ void ReloadExperienceData()
 			default:
 				result = DiscardField(result.next, dataFile.end());
 			}
-		}
 
-		if (isMaxLevelRecord) {
-			ExperienceData.maxLevel = experience == 0 ? ExperienceData::DefaultMaxLevel
-			                                          : static_cast<uint8_t>(std::min<uint32_t>(experience, std::numeric_limits<uint8_t>::max()));
-			foundMaxLevelRecord = true;
-		} else {
-			if (foundMaxLevelRecord && level > ExperienceData.maxLevel) {
-				// ignore values we will never use. Should we notify the player?
-			} else {
-				if (level >= ExperienceData.levelThresholds.size()) {
-					// To avoid ValidatePlayer() resetting players to 0 experience we need to use the maximum possible value here
-					// As long as the file has no gaps it'll get initialised properly.
-					ExperienceData.levelThresholds.resize(static_cast<size_t>(level) + 1, std::numeric_limits<uint32_t>::max());
-				}
-				ExperienceData.levelThresholds[level] = experience;
-			}
+			if (skipRecord)
+				break;
 		}
 
-		if (!result.endOfRecord()) {
+		if (!skipRecord)
+			ExperienceData.setThresholdForLevel(level, experience);
+
+		if (!result.endOfRecord())
 			result = DiscardRemainingFields(result.next, dataFile.end());
-		}
 	} while (!result.endOfFile());
 }
 
@@ -277,7 +284,7 @@ uint32_t GetNextExperienceThresholdForLevel(unsigned level)
 
 uint8_t GetMaximumCharacterLevel()
 {
-	return ExperienceData.maxLevel;
+	return ExperienceData.getMaxLevel();
 }
 
 const _sfx_id herosounds[enum_size<HeroClass>::value][enum_size<HeroSpeech>::value] = {