Feature/veterancy levels

Core/GameEngine/Include/Common/GameCommon.h

@@ -201,12 +201,14 @@ enum VeterancyLevel CPP_11(: Int)
 	LEVEL_VETERAN,
 	LEVEL_ELITE,
 	LEVEL_HEROIC,
+	LEVEL_FOUR,
+	LEVEL_FIVE,
 
 	LEVEL_COUNT,
 	LEVEL_INVALID,
 
 	LEVEL_FIRST = 0,
-	LEVEL_LAST = LEVEL_HEROIC
+	LEVEL_LAST = LEVEL_FIVE
 };
 
 // TheVeterancyNames is defined in GameCommon.cpp

Core/GameEngine/Source/Common/System/GameCommon.cpp

@@ -36,6 +36,8 @@ const char *const TheVeterancyNames[] =
 	"VETERAN",
 	"ELITE",
 	"HEROIC",
+	"LEVEL_FOUR",
+	"LEVEL_FIVE",
 	nullptr
 };
 static_assert(ARRAY_SIZE(TheVeterancyNames) == LEVEL_COUNT + 1, "Incorrect array size");

GeneralsMD/Code/GameEngine/Include/Common/ModelState.h

@@ -288,6 +288,15 @@ enum ModelConditionFlagType CPP_11(: Int)
 	// Ship death
 	MODELCONDITION_SHIP_TOPPLING,
 	MODELCONDITION_SHIP_SINKING,
+
+	// Veterancy ranks beyond HEROIC (appended to preserve existing save values).
+	MODELCONDITION_WEAPONSET_FOUR,
+	MODELCONDITION_WEAPONSET_FIVE,
+
+	// Reserved padding: keeps MODELCONDITION_COUNT distinct from KINDOF_COUNT. BitFlags<N> is keyed only
+	// on its bit count, so two flag enums with an equal COUNT would share one name list (see the guard in
+	// BitFlags.cpp). Do not reuse this slot for a real condition without re-checking the counts.
+	MODELCONDITION_RESERVED_UNIQUE_SIZE_PAD,
 //
 // Note: these values are saved in save files, so you MUST NOT REMOVE OR CHANGE
 // existing values!

GeneralsMD/Code/GameEngine/Include/Common/ThingTemplate.h

@@ -509,6 +509,7 @@ class ThingTemplate : public Overridable
 
 	Int getExperienceValue(Int level) const { return m_experienceValues[level]; }
 	Int getExperienceRequired(Int level) const {return m_experienceRequired[level]; }
+	VeterancyLevel getMaxVeterancyLevel() const { return m_maxVeterancyLevel; }
 	Bool isTrainable() const{return m_isTrainable; }
 	Bool isEnterGuard() const{return m_enterGuard; }
 	Bool isHijackGuard() const{return m_hijackGuard; }
@@ -699,6 +700,9 @@ class ThingTemplate : public Overridable
 	static void parsePrerequisites( INI* ini, void *instance, void * /*store*/, const void* /*userData*/ );
 	static void parseModuleName(INI* ini, void *instance, void* /*store*/, const void* userData);
 	static void parseIntList(INI* ini, void *instance, void* store, const void* userData);
+	static void parseExperienceValueList(INI* ini, void *instance, void* store, const void* userData);
+	static void parseExperienceRequiredList(INI* ini, void *instance, void* store, const void* userData);
+	static void parseSkillPointValueList(INI* ini, void *instance, void* store, const void* userData);
 
 	static void parsePerUnitSounds(INI* ini, void *instance, void* store, const void* userData);
 	static void parsePerUnitFX(INI* ini, void *instance, void* store, const void* userData);
@@ -749,6 +753,7 @@ class ThingTemplate : public Overridable
 	Int											m_skillPointValues[LEVEL_COUNT];
 	Int											m_experienceValues[LEVEL_COUNT];		///< How much I am worth at each experience level
 	Int											m_experienceRequired[LEVEL_COUNT];	///< How many experience points I need for each level
+	VeterancyLevel					m_maxVeterancyLevel;								///< highest veterancy level this object may ever reach
 
 	//Code renderer handles these states now.
 	//AsciiString							m_inventoryImage[ INV_IMAGE_NUM_IMAGES ];  ///< portrait inventory pictures

GeneralsMD/Code/GameEngine/Include/GameClient/ControlBar.h

@@ -1018,6 +1018,8 @@ class ControlBar : public SubsystemInterface
 	static const Image *m_rankVeteranIcon;
 	static const Image *m_rankEliteIcon;
 	static const Image *m_rankHeroicIcon;
+	static const Image *m_rankFourIcon;
+	static const Image *m_rankFiveIcon;
 
 	const Image *m_generalButtonEnable;
 	const Image *m_generalButtonHighlight;

GeneralsMD/Code/GameEngine/Include/GameLogic/ArmorSet.h

@@ -55,6 +55,10 @@ enum ArmorSetType CPP_11(: Int)
 	ARMORSET_PLAYER_UPGRADE3,
 	ARMORSET_PLAYER_UPGRADE4,
 
+	// Veterancy ranks beyond HEROIC. Appended (not inserted) to preserve existing save values.
+	ARMORSET_FOUR,
+	ARMORSET_FIVE,
+
 	ARMORSET_COUNT
 };
 

GeneralsMD/Code/GameEngine/Include/GameLogic/ExperienceTracker.h

@@ -52,6 +52,9 @@ class ExperienceTracker : public MemoryPoolObject, public Snapshot
 
 	void setVeterancyLevel( VeterancyLevel newLevel, Bool provideFeedback = TRUE );						///< Set Level to this
 	void setMinVeterancyLevel( VeterancyLevel newLevel, Bool provideFeedback = TRUE );					///< Set Level to AT LEAST this... if we are already >= this level, do nothing.
+
+	VeterancyLevel getMaxVeterancyLevel() const { return m_maxVeterancyLevel; }				///< Highest level this object may reach (hard cap, regardless of ExperienceRequired).
+	void setMaxVeterancyLevel( VeterancyLevel maxLevel, Bool provideFeedback = TRUE );	///< Change the cap; demotes the current level if it now exceeds the cap.
 	void addExperiencePoints( Int experienceGain, Bool canScaleForBonus = TRUE );	///< Gain this many exp.
 	Bool gainExpForLevel(Int levelsToGain, Bool canScaleForBonus = TRUE );			  ///< Gain enough exp to gain a level. return false if can't gain a level.
 	Bool canGainExpForLevel(Int levelsToGain) const;															///< return same value as gainExpForLevel, but don't change anything
@@ -72,6 +75,7 @@ class ExperienceTracker : public MemoryPoolObject, public Snapshot
 private:
 	Object*						m_parent;														///< Object I am owned by
 	VeterancyLevel		m_currentLevel;											///< Level of experience
+	VeterancyLevel		m_maxVeterancyLevel;								///< Hard cap on the level I can reach (from template, overridable)
 	Int								m_currentExperience;								///< Number of experience points
 	ObjectID					m_experienceSink;										///< ID of object I have pledged my experience point gains to
 	Real							m_experienceScalar;									///< Scales any experience gained by this multiplier.

GeneralsMD/Code/GameEngine/Include/GameLogic/Module/ExperienceScalarUpgrade.h

@@ -49,6 +49,7 @@ class ExperienceScalarUpgradeModuleData: public UpgradeModuleData
 	Bool m_initiallyActive;   // Apply upgrade immediately
 	Real m_addXPScalar;   ///< Additive bonus to scalar for XP this unit gains
 	Real m_addXPValueScalar;  ///< Additive bonus to scalar for XP this unit gives when killed
+	VeterancyLevel m_setMaxVeterancyLevel;  ///< if not LEVEL_INVALID, override the object's max veterancy cap
 
 };
 

GeneralsMD/Code/GameEngine/Include/GameLogic/Object.h

@@ -242,6 +242,8 @@ class Object : public Thing, public Snapshot
 	ExperienceTracker* getExperienceTracker() {return m_experienceTracker;}
 	const ExperienceTracker* getExperienceTracker() const {return m_experienceTracker;}
 	VeterancyLevel getVeterancyLevel() const;
+	VeterancyLevel getMaxVeterancyLevel() const;																			///< highest veterancy level this object may reach (template default, overridable)
+	void setMaxVeterancyLevel( VeterancyLevel maxLevel, Bool provideFeedback = TRUE );	///< override the veterancy cap (e.g. from an upgrade)
 
 	inline const AsciiString& getName() const { return m_name; }
 	inline void setName( const AsciiString& newName ) { m_name = newName; }

GeneralsMD/Code/GameEngine/Include/GameLogic/WeaponBonusConditionType.h

@@ -99,6 +99,10 @@ enum WeaponBonusConditionType CPP_11(: Int)
 	WEAPONBONUSCONDITION_EXTRA7,
 	WEAPONBONUSCONDITION_EXTRA8,
 
+	// Veterancy ranks beyond HEROIC. Appended (not inserted) to preserve existing save values.
+	WEAPONBONUSCONDITION_VETERANCY_FOUR,
+	WEAPONBONUSCONDITION_VETERANCY_FIVE,
+
 
 	WEAPONBONUSCONDITION_COUNT
 };

GeneralsMD/Code/GameEngine/Include/GameLogic/WeaponSet.h

@@ -116,7 +116,9 @@ static const ModelConditionFlagType TheWeaponSetTypeToModelConditionTypeMap[WEAP
 	/*WEAPONSET_PLAYER_UPGRADE3*/						MODELCONDITION_WEAPONSET_PLAYER_UPGRADE3,
 	/*WEAPONSET_PLAYER_UPGRADE4*/						MODELCONDITION_WEAPONSET_PLAYER_UPGRADE4,
 	/*WEAPONSET_GARRISONED*/							MODELCONDITION_INVALID,  //No actual conditionstates needed for Garrisoned and contained
-	/*WEAPONSET_CONTAINED*/								MODELCONDITION_INVALID
+	/*WEAPONSET_CONTAINED*/								MODELCONDITION_INVALID,
+	/*WEAPONSET_FOUR*/										MODELCONDITION_WEAPONSET_FOUR,
+	/*WEAPONSET_FIVE*/										MODELCONDITION_WEAPONSET_FIVE
 };
 #endif
 

GeneralsMD/Code/GameEngine/Include/GameLogic/WeaponSetType.h

@@ -64,5 +64,10 @@ enum WeaponSetType CPP_11(: Int)
 	WEAPONSET_GARRISONED,
 	WEAPONSET_CONTAINED,
 
+	// Veterancy ranks beyond HEROIC. Appended (not inserted) to preserve existing save values and the
+	// positional TheWeaponSetTypeToModelConditionTypeMap ordering.
+	WEAPONSET_FOUR,
+	WEAPONSET_FIVE,
+
 	WEAPONSET_COUNT
 };

GeneralsMD/Code/GameEngine/Source/Common/BitFlags.cpp

@@ -37,6 +37,43 @@
 #include "Common/ModelState.h"
 #include "GameLogic/ArmorSet.h"
 #include "GameLogic/WeaponBonusConditionFlags.h"
+#include "Common/KindOf.h"
+#include "GameLogic/WeaponSetType.h"
+#include "Common/DisabledTypes.h"
+#include "Common/ObjectStatusTypes.h"
+#include "GameLogic/Damage.h"
+#include "Common/SpecialPowerMaskType.h"
+#include "Common/Upgrade.h"
+#include "GameClient/TintStatus.h"
+
+//-------------------------------------------------------------------------------------------------
+// BitFlags<N> is templated ONLY on its bit count, so two enums with the same *_COUNT collapse to the
+// SAME type and share a single static s_bitNameList. When that happens, INI parsing for one flag type
+// silently looks up names in the other's list (e.g. a KindOf parse reading ModelCondition names). Guard
+// against it: every BitFlags specialization's size must be unique. If this assert fires, nudge one enum's
+// COUNT to a free value (e.g. add a reserved padding entry) -- see the free/used counts in this list.
+//-------------------------------------------------------------------------------------------------
+namespace
+{
+	constexpr int s_bitFlagsSizes[] =
+	{
+		KINDOF_COUNT, MODELCONDITION_COUNT, WEAPONBONUSCONDITION_COUNT, WEAPONSET_COUNT,
+		ARMORSET_COUNT, DISABLED_COUNT, OBJECT_STATUS_COUNT, DAMAGE_NUM_TYPES,
+		SPECIALPOWER_COUNT, UPGRADE_MAX_COUNT, TINT_STATUS_COUNT
+	};
+	constexpr bool areBitFlagsSizesUnique()
+	{
+		for (size_t i = 0; i < ARRAY_SIZE(s_bitFlagsSizes); ++i)
+			for (size_t j = i + 1; j < ARRAY_SIZE(s_bitFlagsSizes); ++j)
+				if (s_bitFlagsSizes[i] == s_bitFlagsSizes[j])
+					return false;
+		return true;
+	}
+	static_assert(areBitFlagsSizesUnique(),
+		"Two BitFlags<> specializations share the same bit count; equal counts collapse to the same type "
+		"and share one s_bitNameList, so INI parsing for one flag type will use another's names. Nudge one "
+		"enum's *_COUNT to a unique value (e.g. add a reserved padding entry).");
+}
 
 template<>
 const char* const ModelConditionFlags::s_bitNameList[] =
@@ -220,7 +257,11 @@ const char* const ModelConditionFlags::s_bitNameList[] =
 
 	"SHIP_TOPPLING",
 	"SHIP_SINKING",
-
+
+	"WEAPONSET_FOUR",
+	"WEAPONSET_FIVE",
+	"RESERVED_UNIQUE_SIZE_PAD",
+
 	nullptr
 };
 static_assert(ARRAY_SIZE(ModelConditionFlags::s_bitNameList) == ModelConditionFlags::NumBits + 1, "Incorrect array size");
@@ -239,6 +280,8 @@ const char* const ArmorSetFlags::s_bitNameList[] =
 	"PLAYER_UPGRADE2",
 	"PLAYER_UPGRADE3",
 	"PLAYER_UPGRADE4",
+	"LEVEL_FOUR",
+	"LEVEL_FIVE",
 
 	nullptr
 };
@@ -304,6 +347,8 @@ const char* const WeaponBonusConditionFlags::s_bitNameList[] =
 	"EXTRA6",
 	"EXTRA7",
 	"EXTRA8",
+	"LEVEL_FOUR",
+	"LEVEL_FIVE",
 	nullptr
 };
 static_assert(ARRAY_SIZE(WeaponBonusConditionFlags::s_bitNameList) == WEAPONBONUSCONDITION_COUNT + 1, "Incorrect array size");

GeneralsMD/Code/GameEngine/Source/Common/GlobalData.cpp

@@ -432,6 +432,8 @@ GlobalData* GlobalData::m_theOriginal = nullptr;
 	{ "HealthBonus_Veteran",				INI::parsePercentToReal, nullptr,	offsetof( GlobalData, m_healthBonus[LEVEL_VETERAN]) },
 	{ "HealthBonus_Elite",					INI::parsePercentToReal, nullptr,	offsetof( GlobalData, m_healthBonus[LEVEL_ELITE]) },
 	{ "HealthBonus_Heroic",					INI::parsePercentToReal, nullptr,	offsetof( GlobalData, m_healthBonus[LEVEL_HEROIC]) },
+	{ "HealthBonus_Four",						INI::parsePercentToReal, nullptr,	offsetof( GlobalData, m_healthBonus[LEVEL_FOUR]) },
+	{ "HealthBonus_Five",						INI::parsePercentToReal, nullptr,	offsetof( GlobalData, m_healthBonus[LEVEL_FIVE]) },
 
 	{ "HumanSoloPlayerHealthBonus_Easy",					INI::parsePercentToReal,			nullptr,			offsetof( GlobalData, m_soloPlayerHealthBonusForDifficulty[PLAYER_HUMAN][DIFFICULTY_EASY] ) },
 	{ "HumanSoloPlayerHealthBonus_Normal",				INI::parsePercentToReal,			nullptr,			offsetof( GlobalData, m_soloPlayerHealthBonusForDifficulty[PLAYER_HUMAN][DIFFICULTY_NORMAL] ) },

GeneralsMD/Code/GameEngine/Source/Common/System/Upgrade.cpp

@@ -282,6 +282,12 @@ void UpgradeCenter::init( void )
 	up = newUpgrade("");
 	up->friend_makeVeterancyUpgrade(LEVEL_HEROIC);
 
+	up = newUpgrade("");
+	up->friend_makeVeterancyUpgrade(LEVEL_FOUR);
+
+	up = newUpgrade("");
+	up->friend_makeVeterancyUpgrade(LEVEL_FIVE);
+
 }
 
 //-------------------------------------------------------------------------------------------------

GeneralsMD/Code/GameEngine/Source/Common/Thing/ThingTemplate.cpp

@@ -128,9 +128,10 @@ const FieldParse ThingTemplate::s_objectFieldParseTable[] =
 	{ "FactoryExitWidth",			INI::parseReal,												nullptr,		offsetof( ThingTemplate, m_factoryExitWidth ) },
 	{ "FactoryExtraBibWidth",	INI::parseReal,												nullptr,		offsetof( ThingTemplate, m_factoryExtraBibWidth ) },
 
-	{ "SkillPointValue",			ThingTemplate::parseIntList,					(void*)LEVEL_COUNT,		offsetof( ThingTemplate, m_skillPointValues ) },
-	{ "ExperienceValue",			ThingTemplate::parseIntList,					(void*)LEVEL_COUNT,		offsetof( ThingTemplate, m_experienceValues ) },
-	{ "ExperienceRequired",		ThingTemplate::parseIntList,					(void*)LEVEL_COUNT,		offsetof( ThingTemplate, m_experienceRequired ) },
+	{ "SkillPointValue",			ThingTemplate::parseSkillPointValueList,			nullptr,		offsetof( ThingTemplate, m_skillPointValues ) },
+	{ "ExperienceValue",			ThingTemplate::parseExperienceValueList,			nullptr,		offsetof( ThingTemplate, m_experienceValues ) },
+	{ "ExperienceRequired",		ThingTemplate::parseExperienceRequiredList,		nullptr,		offsetof( ThingTemplate, m_experienceRequired ) },
+	{ "MaxVeterancyLevel",		INI::parseIndexList,				TheVeterancyNames,		offsetof( ThingTemplate, m_maxVeterancyLevel ) },
 	{ "IsTrainable",					INI::parseBool,												nullptr,									offsetof( ThingTemplate, m_isTrainable ) },
 	{ "EnterGuard",						INI::parseBool,												nullptr,									offsetof( ThingTemplate, m_enterGuard ) },
 	{ "HijackGuard",					INI::parseBool,												nullptr,									offsetof( ThingTemplate, m_hijackGuard ) },
@@ -638,6 +639,54 @@ void ThingTemplate::parseIntList(INI* ini, void *instance, void* store, const vo
 	}
 }
 
+//-------------------------------------------------------------------------------------------------
+/** Read a variable-length list of ints (up to LEVEL_COUNT) into a per-veterancy-level array. Returns
+	the number of values actually provided. Used by the veterancy experience parsers so that INI lines
+	which only specify the original four ranks still parse after LEVEL_FOUR/LEVEL_FIVE were added. */
+//-------------------------------------------------------------------------------------------------
+static Int parseVeterancyIntList(INI* ini, Int* intList)
+{
+	Int count = 0;
+	for( const char* token = ini->getNextTokenOrNull(); token != nullptr && count < LEVEL_COUNT; token = ini->getNextTokenOrNull() )
+	{
+		intList[count++] = INI::scanInt(token);
+	}
+	return count;
+}
+
+//-------------------------------------------------------------------------------------------------
+void ThingTemplate::parseExperienceValueList(INI* ini, void *instance, void* store, const void* userData)
+{
+	// Trailing (unspecified) levels inherit the last specified value, so a unit granted FOUR/FIVE is
+	// worth the same as its highest defined rank (normally HEROIC).
+	Int *intList = (Int*)store;
+	Int n = parseVeterancyIntList(ini, intList);
+	Int fill = (n > 0) ? intList[n - 1] : 0;
+	for( Int i = n; i < LEVEL_COUNT; ++i )
+		intList[i] = fill;
+}
+
+//-------------------------------------------------------------------------------------------------
+void ThingTemplate::parseExperienceRequiredList(INI* ini, void *instance, void* store, const void* userData)
+{
+	// Trailing (unspecified) levels are unreachable by default (INT_MAX), so objects cannot climb into
+	// FOUR/FIVE naturally unless the INI explicitly provides a requirement for them.
+	Int *intList = (Int*)store;
+	Int n = parseVeterancyIntList(ini, intList);
+	for( Int i = n; i < LEVEL_COUNT; ++i )
+		intList[i] = INT_MAX;
+}
+
+//-------------------------------------------------------------------------------------------------
+void ThingTemplate::parseSkillPointValueList(INI* ini, void *instance, void* store, const void* userData)
+{
+	// Trailing (unspecified) levels fall back to "use experience value" (which itself inherits HEROIC).
+	Int *intList = (Int*)store;
+	Int n = parseVeterancyIntList(ini, intList);
+	for( Int i = n; i < LEVEL_COUNT; ++i )
+		intList[i] = USE_EXP_VALUE_FOR_SKILL_VALUE;
+}
+
 //-------------------------------------------------------------------------------------------------
 static void parsePrerequisiteUnit( INI* ini, void *instance, void * /*store*/, const void* /*userData*/ )
 {
@@ -1037,10 +1086,14 @@ ThingTemplate::ThingTemplate() :
 	for( Int levelIndex = 0; levelIndex < LEVEL_COUNT; levelIndex++ )
 	{
 		m_experienceValues[levelIndex] = 0;
-		m_experienceRequired[levelIndex] = 0;
+		// Levels beyond HEROIC (FOUR/FIVE) default to an unreachable experience requirement, so objects
+		// can never climb into them naturally -- they only apply when granted explicitly.
+		m_experienceRequired[levelIndex] = (levelIndex > LEVEL_HEROIC) ? INT_MAX : 0;
 		// -1 means "same value as experienceValues for that level"
 		m_skillPointValues[levelIndex] = USE_EXP_VALUE_FOR_SKILL_VALUE;
 	}
+	// By default an object may reach the highest vanilla rank; MaxVeterancyLevel can cap it lower.
+	m_maxVeterancyLevel = LEVEL_HEROIC;
 	m_isTrainable = FALSE;
 	m_enterGuard = FALSE;
 	m_hijackGuard = FALSE;

GeneralsMD/Code/GameEngine/Source/GameClient/Drawable.cpp

@@ -327,6 +327,8 @@ const Int MAX_ENABLED_MODULES								= 16;
  	s_veterancyImage[1] = TheMappedImageCollection->findImageByName("SCVeter1");
 	s_veterancyImage[2] = TheMappedImageCollection->findImageByName("SCVeter2");
 	s_veterancyImage[3] = TheMappedImageCollection->findImageByName("SCVeter3");
+	s_veterancyImage[4] = TheMappedImageCollection->findImageByName("SCVeter4");
+	s_veterancyImage[5] = TheMappedImageCollection->findImageByName("SCVeter5");
 
 	s_fullAmmo	= TheMappedImageCollection->findImageByName("SCPAmmoFull");
 	s_emptyAmmo	= TheMappedImageCollection->findImageByName("SCPAmmoEmpty");

GeneralsMD/Code/GameEngine/Source/GameClient/GUI/ControlBar/ControlBar.cpp

@@ -91,6 +91,8 @@ ControlBar *TheControlBar = nullptr;
 const Image* ControlBar::m_rankVeteranIcon	= nullptr;
 const Image* ControlBar::m_rankEliteIcon		= nullptr;
 const Image* ControlBar::m_rankHeroicIcon		= nullptr;
+const Image* ControlBar::m_rankFourIcon			= nullptr;
+const Image* ControlBar::m_rankFiveIcon			= nullptr;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // CommandButton //////////////////////////////////////////////////////////////////////////////////
@@ -1307,6 +1309,8 @@ void ControlBar::init( void )
 		m_rankVeteranIcon = TheMappedImageCollection ? TheMappedImageCollection->findImageByName( "SSChevron1L" ) : nullptr;
 		m_rankEliteIcon		= TheMappedImageCollection ? TheMappedImageCollection->findImageByName( "SSChevron2L" ) : nullptr;
 		m_rankHeroicIcon	= TheMappedImageCollection ? TheMappedImageCollection->findImageByName( "SSChevron3L" ) : nullptr;
+		m_rankFourIcon		= TheMappedImageCollection ? TheMappedImageCollection->findImageByName( "SSChevron4L" ) : nullptr;
+		m_rankFiveIcon		= TheMappedImageCollection ? TheMappedImageCollection->findImageByName( "SSChevron5L" ) : nullptr;
 
 
 //		if(!m_controlBarResizer)

GeneralsMD/Code/GameEngine/Source/GameClient/GUI/ControlBar/ControlBarCommand.cpp

@@ -959,6 +959,10 @@ const Image* ControlBar::calculateVeterancyOverlayForThing( const ThingTemplate
 			return m_rankEliteIcon;
 		case LEVEL_HEROIC:
 			return m_rankHeroicIcon;
+		case LEVEL_FOUR:
+			return m_rankFourIcon;
+		case LEVEL_FIVE:
+			return m_rankFiveIcon;
 	}
 	return nullptr;
 }
@@ -981,6 +985,10 @@ const Image* ControlBar::calculateVeterancyOverlayForObject( const Object *obj )
 			return m_rankEliteIcon;
 		case LEVEL_HEROIC:
 			return m_rankHeroicIcon;
+		case LEVEL_FOUR:
+			return m_rankFourIcon;
+		case LEVEL_FIVE:
+			return m_rankFiveIcon;
 	}
 	return nullptr;
 }