Replace C casts with C++ casts

Author: MaximDude

System/Color.cpp

@@ -62,7 +62,7 @@ namespace RTE {
 		m_Index = index;
 
 		RGB color;
-		get_color((int)m_Index, &color);
+		get_color(static_cast<int>(m_Index), &color);
 
 		m_R = color.r * 4;
 		m_G = color.g * 4;

System/Matrix.cpp

@@ -38,8 +38,8 @@ namespace RTE {
 		m_ElementsUpdated = true;
 
 		// Inverse angle to make CCW positive direction.
-		float const CosAngle = (float)cos(-angle);
-		float const SinAngle = (float)sin(-angle);
+		float const CosAngle = static_cast<float>(cos(-angle));
+		float const SinAngle = static_cast<float>(sin(-angle));
 		m_Elements[0][0] = CosAngle;
 		m_Elements[0][1] = -SinAngle;
 		m_Elements[1][0] = SinAngle;
@@ -176,8 +176,8 @@ namespace RTE {
 
 	void Matrix::UpdateElements() {
 		// Inverse angle to make CCW positive direction.
-		float const CosAngle = (float)cos(-m_Rotation);
-		float const SinAngle = (float)sin(-m_Rotation);
+		float const CosAngle = static_cast<float>(cos(-m_Rotation));
+		float const SinAngle = static_cast<float>(sin(-m_Rotation));
 		m_Elements[0][0] = CosAngle;
 		m_Elements[0][1] = -SinAngle;
 		m_Elements[1][0] = SinAngle;

System/PathFinder.cpp

@@ -21,17 +21,17 @@ namespace RTE {
 		int sceneHeight = g_SceneMan.GetSceneHeight();
 
 		// Make overlapping nodes at seams if necessary, to make sure all scene pixels are covered
-		int nodeXCount = ceilf((float)sceneWidth / (float)m_NodeDimension);
-		int nodeYCount = ceilf((float)sceneHeight / (float)m_NodeDimension);
+		int nodeXCount = ceilf(static_cast<float>(sceneWidth) / static_cast<float>(m_NodeDimension));
+		int nodeYCount = ceilf(static_cast<float>(sceneHeight) / static_cast<float>(m_NodeDimension));
 
 		// Create and assign scene coordinate positions for all nodes
 		PathNode *pNode = 0;
-		Vector nodePos = Vector((float)nodeDimension / 2.0F, (float)nodeDimension / 2.0F);
+		Vector nodePos = Vector(static_cast<float>(nodeDimension) / 2.0F, static_cast<float>(nodeDimension) / 2.0F);
 		for (int x = 0; x < nodeXCount; ++x) {
 			// Make sure no cell centers are off the scene (since they can overlap the far edge of the scene)
 			if (nodePos.m_X >= sceneWidth) { nodePos.m_X = sceneWidth - 1; }
 			// Start the column height over at middle of the top node each new column
-			nodePos.m_Y = (float)nodeDimension / 2.0F;
+			nodePos.m_Y = static_cast<float>(nodeDimension) / 2.0F;
 			// Create the new column and fill it out
 			vector<PathNode *> newColumn;
 			for (int y = 0; y < nodeYCount; ++y) {
@@ -120,10 +120,10 @@ namespace RTE {
 		g_SceneMan.ForceBounds(end);
 
 		// Convert from absolute scene pixel coordinates to path node indices
-		int startNodeX = floorf(start.m_X / (float)m_NodeDimension);
-		int startNodeY = floorf(start.m_Y / (float)m_NodeDimension);
-		int endNodeX = floorf(end.m_X / (float)m_NodeDimension);
-		int endNodeY = floorf(end.m_Y / (float)m_NodeDimension);
+		int startNodeX = floorf(start.m_X / static_cast<float>(m_NodeDimension));
+		int startNodeY = floorf(start.m_Y / static_cast<float>(m_NodeDimension));
+		int endNodeX = floorf(end.m_X / static_cast<float>(m_NodeDimension));
+		int endNodeY = floorf(end.m_Y / static_cast<float>(m_NodeDimension));
 
 		// Clear out the results if it happens to contain anything
 		pathResult.clear();
@@ -321,10 +321,10 @@ namespace RTE {
 		box.Unflip();
 
 		// Get the extents of the box' potential influence on nodes and their connecting edges
-		int firstX = floorf((box.m_Corner.m_X / (float)m_NodeDimension) + 0.5F) - 1;
-		int lastX = floorf(((box.m_Corner.m_X + box.m_Width) / (float)m_NodeDimension) + 0.5F) + 1;
-		int firstY = floorf((box.m_Corner.m_Y / (float)m_NodeDimension) + 0.5F) - 1;
-		int lastY = floorf(((box.m_Corner.m_Y + box.m_Height) / (float)m_NodeDimension) + 0.5F) + 1;
+		int firstX = floorf((box.m_Corner.m_X / static_cast<float>(m_NodeDimension)) + 0.5F) - 1;
+		int lastX = floorf(((box.m_Corner.m_X + box.m_Width) / static_cast<float>(m_NodeDimension)) + 0.5F) + 1;
+		int firstY = floorf((box.m_Corner.m_Y / static_cast<float>(m_NodeDimension)) + 0.5F) - 1;
+		int lastY = floorf(((box.m_Corner.m_Y + box.m_Height) / static_cast<float>(m_NodeDimension)) + 0.5F) + 1;
 
 		// Truncate the influence
 		if (firstX < 0) { firstX = 0; }

System/RTEError.h

@@ -38,10 +38,10 @@ namespace RTE {
 	#define RTEAssert(expression, description) {													\
 		static bool alwaysIgnore = false;															\
 		if (!alwaysIgnore) {																		\
-			if (RTEAssertFunc((int)(expression), description, __FILE__, __LINE__, alwaysIgnore)) {	\
 				__debugbreak();																		\
 			}																						\
 		}																							\
+			if (RTEAssertFunc(expression, description, __FILE__, __LINE__, alwaysIgnore)) {		\
 	}
 }
 #endif

System/RTETools.cpp

@@ -21,7 +21,7 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	int SelectRand(int min, int max) { return min + (int)((max - min) * PosRand() + 0.5); }
+	int SelectRand(int min, int max) { return min + static_cast<int>((max - min) * PosRand() + 0.5); }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 

System/Timer.cpp

@@ -16,15 +16,15 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	int Timer::Create() {
-		m_TicksPerMS = (double)g_TimerMan.GetTicksPerSecond() * 0.001;
+		m_TicksPerMS = static_cast<double>(g_TimerMan.GetTicksPerSecond()) * 0.001;
 		return 0;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	int Timer::Create(unsigned long elapsedSimTime) {
 		SetElapsedSimTimeMS(elapsedSimTime);
-		m_TicksPerMS = (double)g_TimerMan.GetTicksPerSecond() * 0.001;
+		m_TicksPerMS = static_cast<double>(g_TimerMan.GetTicksPerSecond()) * 0.001;
 		return 0;
 	}
 
@@ -35,7 +35,7 @@ namespace RTE {
 		m_StartSimTime = reference.m_StartSimTime;
 		m_RealTimeLimit = reference.m_RealTimeLimit;
 		m_SimTimeLimit = reference.m_SimTimeLimit;
-		m_TicksPerMS = (double)g_TimerMan.GetTicksPerSecond() * 0.001;
+		m_TicksPerMS = static_cast<double>(g_TimerMan.GetTicksPerSecond()) * 0.001;
 		return 0;
 	}
 }

System/Timer.h

@@ -91,20 +91,20 @@ namespace RTE {
 		/// This is when the timer is supposed to show that it has 'expired' or reached whatever time limit it is supposed to keep track of.
 		/// </summary>
 		/// <returns>A positive double with the real time limit relative to the start time.</returns>
-		double GetRealTimeLimitS() const { return m_RealTimeLimit / (double)g_TimerMan.GetTicksPerSecond(); }
+		double GetRealTimeLimitS() const { return m_RealTimeLimit / static_cast<double>(g_TimerMan.GetTicksPerSecond()); }
 
 		/// <summary>
 		/// Sets the real time limit value of this Timer, RELATVE to the start time.
 		/// This is when the timer is supposed to show that it has 'expired' or reached whatever time limit it is supposed to keep track of.
 		/// </summary>
 		/// <param name="newTimeLimit">A positive double with the new real time limit relative to the start time.</param>
-		void SetRealTimeLimitS(double newTimeLimit) { m_RealTimeLimit = newTimeLimit * (double)g_TimerMan.GetTicksPerSecond(); }
+		void SetRealTimeLimitS(double newTimeLimit) { m_RealTimeLimit = newTimeLimit * static_cast<double>(g_TimerMan.GetTicksPerSecond()); }
 
 		/// <summary>
 		/// Gets the elapsed real time in ms since this Timer was Reset().
 		/// </summary>
 		/// <returns>A unsigned long value that represents the elapsed real time since Reset() in ms.</returns>
-		double GetElapsedRealTimeMS() const { return (double)(g_TimerMan.GetRealTickCount() - m_StartRealTime) / m_TicksPerMS; }
+		double GetElapsedRealTimeMS() const { return static_cast<double>(g_TimerMan.GetRealTickCount() - m_StartRealTime) / m_TicksPerMS; }
 
 		/// <summary>
 		/// Sets the start real time value of this Timer, in seconds.
@@ -116,13 +116,13 @@ namespace RTE {
 		/// Gets the elapsed real time in seconds since this Timer was Reset().
 		/// </summary>
 		/// <returns>A double value that represents the elapsed real time since Reset() in s.</returns>
-		double GetElapsedRealTimeS() const { return (double)(g_TimerMan.GetRealTickCount() - m_StartRealTime) / (double)g_TimerMan.GetTicksPerSecond(); }
+		double GetElapsedRealTimeS() const { return static_cast<double>(g_TimerMan.GetRealTickCount() - m_StartRealTime) / static_cast<double>(g_TimerMan.GetTicksPerSecond()); }
 
 		/// <summary>
 		/// Sets the start real time value of this Timer.
 		/// </summary>
 		/// <param name="newElapsedRealTime">An int64 with the new elapsed time value in seconds.</param>
-		void SetElapsedRealTimeS(const double newElapsedRealTime) { m_StartRealTime = g_TimerMan.GetRealTickCount() - (newElapsedRealTime * (double)g_TimerMan.GetTicksPerSecond()); }
+		void SetElapsedRealTimeS(const double newElapsedRealTime) { m_StartRealTime = g_TimerMan.GetRealTickCount() - (newElapsedRealTime * static_cast<double>(g_TimerMan.GetTicksPerSecond())); }
 
 		/// <summary>
 		/// Returns how much time in ms that there is left till this Timer reaches a certain time limit.
@@ -148,7 +148,7 @@ namespace RTE {
 		/// Returns how much time in ms that there is left till this Timer reaches a certain time limit previously set by SetRealTimeLimitS.
 		/// </summary>
 		/// <returns>A unsigned long with the real time left till the passed in value, or negative if this Timer is already past that point in time.</returns>
-		double LeftTillRealTimeLimitS() { return (m_RealTimeLimit * (double)g_TimerMan.GetTicksPerSecond()) - GetElapsedRealTimeS(); }
+		double LeftTillRealTimeLimitS() { return (m_RealTimeLimit * static_cast<double>(g_TimerMan.GetTicksPerSecond())) - GetElapsedRealTimeS(); }
 
 		/// <summary>
 		/// Returns true if the elapsed real time is past a certain amount of time after the start previously set by SetRealTimeLimit.
@@ -169,7 +169,7 @@ namespace RTE {
 		/// </summary>
 		/// <param name="period">An int with the alternating period in ms. The time specified here is how long it will take for the switch to alternate.</param>
 		/// <returns>Whether the elapsed time is in the first state or not.</returns>
-		bool AlternateReal(int period) const { return ((int)GetElapsedRealTimeMS() % (period * 2)) > period; }
+		bool AlternateReal(int period) const { return (static_cast<int>(GetElapsedRealTimeMS()) % (period * 2)) > period; }
 #pragma endregion
 
 #pragma region Simulation Time
@@ -204,20 +204,20 @@ namespace RTE {
 		/// This is when the timer is supposed to show that it has 'expired' or reached whatever time limit it is supposed to keep track of.
 		/// </summary>
 		/// <returns>A positive double with the sim time limit relative to the start time.</returns>
-		double GetSimTimeLimitS() const { return m_SimTimeLimit / (double)g_TimerMan.GetTicksPerSecond(); }
+		double GetSimTimeLimitS() const { return m_SimTimeLimit / static_cast<double>(g_TimerMan.GetTicksPerSecond()); }
 
 		/// <summary>
 		/// Sets the sim time limit value of this Timer, RELATVE to the start time.
 		/// This is when the timer is supposed to show that it has 'expired' or reached whatever time limit it is supposed to keep track of.
 		/// </summary>
 		/// <param name="newTimeLimit">A positive double with the new sim time limit relative to the start time.</param>
-		void SetSimTimeLimitS(double newTimeLimit) { m_SimTimeLimit = newTimeLimit * (double)g_TimerMan.GetTicksPerSecond(); }
+		void SetSimTimeLimitS(double newTimeLimit) { m_SimTimeLimit = newTimeLimit * static_cast<double>(g_TimerMan.GetTicksPerSecond()); }
 
 		/// <summary>
 		/// Gets the elapsed time in ms since this Timer was Reset().
 		/// </summary>
 		/// <returns>A unsigned long value that represents the elapsed time since Reset() in ms.</returns>
-		double GetElapsedSimTimeMS() const { return (double)(g_TimerMan.GetSimTickCount() - m_StartSimTime) / m_TicksPerMS; }
+		double GetElapsedSimTimeMS() const { return static_cast<double>(g_TimerMan.GetSimTickCount() - m_StartSimTime) / m_TicksPerMS; }
 
 		/// <summary>
 		/// Sets the start time value of this Timer, in ms.
@@ -229,13 +229,13 @@ namespace RTE {
 		/// Gets the elapsed time in s since this Timer was Reset().
 		/// </summary>
 		/// <returns>A unsigned long value that represents the elapsed time since Reset() in s.</returns>
-		double GetElapsedSimTimeS() const { return (double)(g_TimerMan.GetSimTickCount() - m_StartSimTime) / (double)g_TimerMan.GetTicksPerSecond(); }
+		double GetElapsedSimTimeS() const { return static_cast<double>(g_TimerMan.GetSimTickCount() - m_StartSimTime) / static_cast<double>(g_TimerMan.GetTicksPerSecond()); }
 
 		/// <summary>
 		/// Sets the start time value of this Timer, in seconds.
 		/// </summary>
 		/// <param name="newElapsedSimTime">An int64 with the new elapsed time value in seconds.</param>
-		void SetElapsedSimTimeS(const double newElapsedSimTime) { m_StartSimTime = g_TimerMan.GetSimTickCount() - (newElapsedSimTime * (double)g_TimerMan.GetTicksPerSecond()); }
+		void SetElapsedSimTimeS(const double newElapsedSimTime) { m_StartSimTime = g_TimerMan.GetSimTickCount() - (newElapsedSimTime * static_cast<double>(g_TimerMan.GetTicksPerSecond())); }
 
 		/// <summary>
 		/// Returns how much time in ms that there is left till this Timer reaches a certain time limit.a certain time limit.
@@ -261,7 +261,7 @@ namespace RTE {
 		/// Returns how much time in ms that there is left till this Timer reaches a certain time limit previously set by SetSimTimeLimitS.
 		/// </summary>
 		/// <returns>A unsigned long with the sim time left till the passed in value, or negative if this Timer is already past that point in time.</returns>
-		double LeftTillSimTimeLimitS() const { return (m_SimTimeLimit * (double)g_TimerMan.GetTicksPerSecond()) - GetElapsedSimTimeS(); }
+		double LeftTillSimTimeLimitS() const { return (m_SimTimeLimit * static_cast<double>(g_TimerMan.GetTicksPerSecond())) - GetElapsedSimTimeS(); }
 
 		/// <summary>
 		/// Returns true if the elapsed sim time is past a certain amount of time after the start previously set by SetSimTimeLimit.
@@ -282,7 +282,7 @@ namespace RTE {
 		/// </summary>
 		/// <param name="period">An int with the alternating period in ms. The time specified here is how long it will take for the switch to alternate.</param>
 		/// <returns>Whether the elapsed time is in the first state or not.</returns>
-		bool AlternateSim(int period) const { if (period == 0) return true; else return ((int)GetElapsedSimTimeMS() % (period * 2)) > period; }
+		bool AlternateSim(int period) const { return (period == 0) ? true : (static_cast<int>(GetElapsedSimTimeMS()) % (period * 2)) > period; }
 #pragma endregion
 
 #pragma region Class Info

System/Vector.h

@@ -91,7 +91,7 @@ namespace RTE {
 		/// Sets the X value of this Vector.
 		/// </summary>
 		/// <param name="newX">An int value that the X value will be set to.</param>
-		void SetIntX(const int newX) { m_X = (float)newX; }
+		void SetIntX(const int newX) { m_X = static_cast<float>(newX); }
 
 		/// <summary>
 		/// Gets the Y value of this Vector.
@@ -109,7 +109,7 @@ namespace RTE {
 		/// Sets the Y value of this Vector.
 		/// </summary>
 		/// <param name="newY">An int value that the Y value will be set to.</param>
-		void SetIntY(const int newY) { m_Y = (float)newY; }
+		void SetIntY(const int newY) { m_Y = static_cast<float>(newY); }
 
 		/// <summary>
 		/// Sets both the X and Y values of this Vector.
@@ -123,7 +123,7 @@ namespace RTE {
 		/// </summary>
 		/// <param name="newX">An int value that the X value will be set to.</param>
 		/// <param name="newY">An int value that the Y value will be set to.</param>
-		void SetIntXY(const int newX, const int newY) { m_X = (float)newX; m_Y = (float)newY; }
+		void SetIntXY(const int newX, const int newY) { m_X = static_cast<float>(newX); m_Y = static_cast<float>(newY); }
 
 		/// <summary>
 		/// Gets the absolute largest of the two elements. Will always be positive.