Review changes, misc cleanup and changes

Author: MaximDude

System/Box.cpp

@@ -139,19 +139,11 @@ namespace RTE {
 		if (IsEmpty() || rhs.IsEmpty()) {
 			return false;
 		}
-
 		Box box1 = *this;
 		Box box2 = rhs;
 		box1.Unflip();
 		box2.Unflip();
 		return (box1.m_Corner.m_X < box2.m_Corner.m_X + box2.m_Width) && (box1.m_Corner.m_X + box1.m_Width > box2.m_Corner.m_X) &&
 			(box1.m_Corner.m_Y < box2.m_Corner.m_Y + box2.m_Height) && (box1.m_Corner.m_Y + box1.m_Height > box2.m_Corner.m_Y);
 	}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-	Box & Box::operator=(const Box &rhs) {
-		if (*this != rhs) { Create(rhs); }
-		return *this;
-	}
 }

System/Box.h

@@ -249,7 +249,7 @@ namespace RTE {
 		/// </summary>
 		/// <param name="rhs">A Box reference.</param>
 		/// <returns>A reference to the changed Box.</returns>
-		Box & operator=(const Box &rhs);
+		Box & operator=(const Box &rhs) { if (*this != rhs) { Create(rhs); } return *this; }
 
 		/// <summary>
 		/// An equality operator for testing if any two Boxes are equal.

System/ContentFile.cpp

@@ -2,6 +2,7 @@
 #include "PresetMan.h"
 
 namespace RTE {
+
 	const std::string ContentFile::m_ClassName = "ContentFile";
 
 	std::map<std::string, BITMAP *> ContentFile::m_sLoadedBitmaps[BitDepthCount];
@@ -16,7 +17,7 @@ namespace RTE {
 		//m_DataModified = false;
 		//m_pLoadedData = 0;
 		//m_LoadedDataSize = 0;
-		m_pDataFile = 0;
+		//m_pDataFile = 0;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -45,10 +46,14 @@ namespace RTE {
 
 	void ContentFile::FreeAllLoaded() {
 		for (int depth = Eight; depth < BitDepthCount; ++depth) {
-			for (std::map<std::string, BITMAP *>::iterator lbItr = m_sLoadedBitmaps[depth].begin(); lbItr != m_sLoadedBitmaps[depth].end(); ++lbItr) { destroy_bitmap((*lbItr).second); }
+			for (std::map<std::string, BITMAP *>::iterator lbItr = m_sLoadedBitmaps[depth].begin(); lbItr != m_sLoadedBitmaps[depth].end(); ++lbItr) {
+				destroy_bitmap((*lbItr).second);
+			}
 		}
 #ifdef __USE_SOUND_FMOD
-		for (std::map<std::string, FSOUND_SAMPLE *>::iterator lcItr = m_sLoadedSamples.begin(); lcItr != m_sLoadedSamples.end(); ++lcItr) { FSOUND_Sample_Free((*lcItr).second); }
+		for (std::map<std::string, FSOUND_SAMPLE *>::iterator lcItr = m_sLoadedSamples.begin(); lcItr != m_sLoadedSamples.end(); ++lcItr) {
+			FSOUND_Sample_Free((*lcItr).second);
+		}
 #endif
 	}
 
@@ -75,7 +80,6 @@ namespace RTE {
 			writer.NewProperty("FilePath");
 			writer << m_DataPath;
 		}
-
 		return 0;
 	}
 
@@ -100,7 +104,6 @@ namespace RTE {
 		if (m_DataPath.empty()) {
 			return 0;
 		}
-
 		BITMAP *pReturnBitmap = 0;
 
 		// Determine the bit depth this bitmap will be loaded as
@@ -117,7 +120,6 @@ namespace RTE {
 			// Insert the bitmap into the map, PASSING OVER OWNERSHIP OF THE LOADED DATAFILE
 			m_sLoadedBitmaps[bitDepth].insert(std::pair<std::string, BITMAP *>(m_DataPath, pReturnBitmap));
 		}
-
 		return pReturnBitmap;
 	}
 
@@ -128,10 +130,10 @@ namespace RTE {
 			return 0;
 		}
 		BITMAP *pReturnBitmap = 0;
-
 		set_color_conversion(conversionMode == 0 ? COLORCONV_MOST : conversionMode);
 
-		int separatorPos = m_DataPath.find('#'); // Used for handling separators between the datafile name and the object name in .dat datafiles. NOTE: Not currently used
+		// Used for handling separators between the datafile name and the object name in .dat datafiles. NOTE: Not currently used
+		int separatorPos = m_DataPath.find('#');
 
 		if (separatorPos == m_DataPath.length()) {
 			RTEAbort("There was no object name following first pound sign in the ContentFile's datafile path, which means there was no actual object defined. The path was:\n\n" + m_DataPath);
@@ -147,22 +149,24 @@ namespace RTE {
 				pFile = pack_fopen((pathWithoutExtension + "000.bmp").c_str(), F_READ);
 				RTEAssert(pFile, "Failed to load datafile object with following path and name:\n\n" + m_DataPath);
 			}
-
-			// Load the bitmap then close the filestream to clean up
+			// Load the bitmap then close the file stream to clean up
 			PALETTE currentPalette;
 			get_palette(currentPalette);
 
 			pReturnBitmap = load_bmp_pf(pFile, (RGB *)currentPalette);
 			pack_fclose(pFile);
 		} else if (separatorPos != m_DataPath.length() - 1) {
+			RTEAbort("Loading bitmaps from allegro datafiles isn't supported yet!");
+			// Used for loading from DataFiles, disabled because we don't have this properly implemented right now. 
+			/*
 			// Split the datapath into the path and the object name and load the datafile from them
 			m_pDataFile = load_datafile_object(m_DataPath.substr(0, separatorPos).c_str(), m_DataPath.substr(separatorPos + 1).c_str());
 			RTEAssert(m_pDataFile && m_pDataFile->dat && m_pDataFile->type == DAT_BITMAP, "Failed to load datafile object with following path and name:\n\n" + m_DataPath);
 
 			pReturnBitmap = (BITMAP *)m_pDataFile->dat;
+			*/
 		}
 		RTEAssert(pReturnBitmap, "Failed to load datafile object with following path and name:\n\n" + m_DataPath);
-
 		return pReturnBitmap;
 	}
 
@@ -172,7 +176,6 @@ namespace RTE {
 		if (m_DataPath.empty()) {
 			return 0;
 		}
-
 		// Create the array of as many BITMAP pointers as requested frames
 		BITMAP **aReturnBitmaps = new BITMAP *[frameCount];
 
@@ -181,9 +184,9 @@ namespace RTE {
 			aReturnBitmaps[0] = GetAsBitmap(conversionMode);
 			return aReturnBitmaps;
 		}
-
 		std::string extension = "";
-		int separatorPos = m_DataPath.find('#'); // Used for handling separators between the datafile name and the object name in .dat datafiles. NOTE: Not currently used
+		// Used for handling separators between the datafile name and the object name in .dat datafiles. NOTE: Not currently used
+		int separatorPos = m_DataPath.find('#');
 		int extensionPos = 0;
 
 		// No separator, need to separate file extension from datapath
@@ -193,7 +196,6 @@ namespace RTE {
 			extension.assign(m_DataPath, extensionPos, m_DataPath.length() - extensionPos);
 			m_DataPath.resize(extensionPos);
 		}
-
 		std::string originalDataPath = m_DataPath;
 		char framePath[1024];
 		// For each frame in the animation, temporarily assign it to the datapath member var so that GetAsBitmap and then load it with GetBitmap
@@ -205,7 +207,6 @@ namespace RTE {
 			RTEAssert(aReturnBitmaps[i], "Could not get a frame of animation with path and name:\n\n" + m_DataPath);
 		}
 		m_DataPath = originalDataPath + (extensionPos > 0 ? extension : "");
-
 		return aReturnBitmaps;
 	}
 
@@ -264,7 +265,6 @@ namespace RTE {
 				pReturnSample = (FSOUND_SAMPLE *)m_pDataFile->dat;
 				*/
 			}
-
 			RTEAssert(pReturnSample, "Failed to load datafile object with following path and name:\n\n" + m_DataPath);
 
 			// Insert the Sound object into the map, PASSING OVER OWNERSHIP OF THE LOADED DATAFILE

System/ContentFile.h

@@ -16,7 +16,7 @@ struct FSOUND_STREAM;
 struct ga_Handle;
 #endif
 
-struct DATAFILE;
+//struct DATAFILE; // DataFile loading not implemented.
 struct BITMAP;
 
 namespace RTE {
@@ -183,10 +183,10 @@ namespace RTE {
 		virtual BITMAP *LoadAndReleaseBitmap(int conversionMode = 0);
 
 		/// <summary>
-		/// Gets the data represented by this ContentFile object as an array of Allegro BITMAPs, each represting a frame in the animation. It loads the BITMAPs into the static maps if they're not already loaded.
+		/// Gets the data represented by this ContentFile object as an array of Allegro BITMAPs, each representing a frame in the animation. It loads the BITMAPs into the static maps if they're not already loaded.
 		/// Note that ownership of the BITMAPS ARE NOT TRANSFERRED, BUT THE ARRAY ITSELF, IS!
 		/// </summary>
-		/// <param name="frameCount">The number of frames to attempt to load, more than 1 frmae will mean 00# is appended to datapath to handle naming conventions.</param>
+		/// <param name="frameCount">The number of frames to attempt to load, more than 1 frame will mean 00# is appended to datapath to handle naming conventions.</param>
 		/// <param name="conversionMode">
 		/// The Allegro color conversion mode to use when loading this bitmap.
 		/// Note it will only apply the first time you get a bitmap since it is only loaded from disk the first time. See allegro docs for the modes.
@@ -219,10 +219,11 @@ namespace RTE {
 #pragma endregion
 
 	protected:
-		enum BitDepths { Eight = 0, ThirtyTwo, BitDepthCount }; //!< Enumeration for loading BITMAPs by bit depth. NOTE: This can't be lower down because m_sLoadedBitmaps relies on its definition
 
 		static const std::string m_ClassName; //!< A string with the friendly-formatted type name of this object.01, 002 etc.
 
+		enum BitDepths { Eight = 0, ThirtyTwo, BitDepthCount }; //!< Enumeration for loading BITMAPs by bit depth. NOTE: This can't be lower down because m_sLoadedBitmaps relies on its definition.
+
 		//TODO all of these could probably be replaced with unordered_maps and decrease lookup time.
 		static std::map<size_t, std::string> m_PathHashes; //!< Hash value of the path to this ContentFile's Datafile Object.
 		static std::map<std::string, BITMAP *> m_sLoadedBitmaps[BitDepthCount]; //!< Static map containing all the already loaded BITMAPs and their paths, and there's two maps, for each bit depth.
@@ -238,7 +239,7 @@ namespace RTE {
 		//long m_LoadedDataSize; //!< Size of loaded data.
 		//bool m_DataModified; //!< Whether the data itself has been modified since load, and should be saved out again to the path on write.
 
-		DATAFILE *m_pDataFile; //!< This is only if the data is loaded from a datafile; needs to be saved so that it can be unloaded as some point.
+		//DATAFILE *m_pDataFile; //!< This is only if the data is loaded from a datafile; needs to be saved so that it can be unloaded as some point.
 
 	private:
 

System/Controller.cpp

@@ -5,13 +5,12 @@
 
 namespace RTE {
 
-	const int Controller::m_ReleaseDelay = 250;
-
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void Controller::Clear() {
-		for (int i = 0; i < CONTROLSTATECOUNT; ++i) { m_ControlStates[i] = false; }
-
+		for (int i = 0; i < CONTROLSTATECOUNT; ++i) {
+			m_ControlStates[i] = false;
+		}
 		m_AnalogMove.Reset();
 		m_AnalogAim.Reset();
 		m_AnalogCursor.Reset();
@@ -47,8 +46,9 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	int Controller::Create(const Controller &reference) {
-		for (int i = 0; i < CONTROLSTATECOUNT; ++i) { m_ControlStates[i] = reference.m_ControlStates[i]; }
-
+		for (int i = 0; i < CONTROLSTATECOUNT; ++i) {
+			m_ControlStates[i] = reference.m_ControlStates[i];
+		}
 		m_AnalogMove = reference.m_AnalogMove;
 		m_AnalogAim = reference.m_AnalogAim;
 		m_AnalogCursor = reference.m_AnalogCursor;
@@ -122,7 +122,7 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	int Controller::GetTeam() const {
-		return (m_pControlled) ? m_pControlled->GetTeam() : m_Team;
+		return m_pControlled ? m_pControlled->GetTeam() : m_Team;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -136,8 +136,9 @@ namespace RTE {
 
 	void Controller::Update() {
 		// Reset all command states.
-		for (int i = 0; i < CONTROLSTATECOUNT; ++i) { m_ControlStates[i] = false; }
-
+		for (int i = 0; i < CONTROLSTATECOUNT; ++i) {
+			m_ControlStates[i] = false;
+		}
 		m_AnalogMove.Reset();
 		m_AnalogAim.Reset();
 		m_AnalogCursor.Reset();
@@ -334,7 +335,7 @@ namespace RTE {
 			m_KeyAccelTimer.Reset();
 		}
 
-		// Translate analog aim input into sharp aim constrol state
+		// Translate analog aim input into sharp aim control state
 		m_ControlStates[AIM_SHARP] = m_AnalogAim.GetMagnitude() > 0.1 && !m_ControlStates[PIE_MENU_ACTIVE];
 
 		// Disable sharp aim while moving - this also helps with keyboard vs mouse fighting when moving and aiming in opposite directions

System/Controller.h

@@ -69,7 +69,7 @@ namespace RTE {
 		Vector m_AnalogAim; //!< Analog values for aiming.
 		Vector m_AnalogCursor; //!< Analog values for Pie Menu operation.
 
-		// Enumerate different input modes.
+		//!< Enumerate different input modes.
 		enum InputMode {
 			CIM_DISABLED = 0,
 			CIM_PLAYER,
@@ -301,6 +301,8 @@ namespace RTE {
 
 	protected:
 
+		static constexpr int m_ReleaseDelay = 250; //!< The delay between releasing a menu button and activating the regular controls, to avoid accidental input.
+
 		bool m_ControlStates[CONTROLSTATECOUNT]; //!< Control states.
 		bool m_Disabled; //!< Quick and easy disable to prevent updates from being made.
 
@@ -330,7 +332,6 @@ namespace RTE {
 		bool m_WeaponDropIgnore;
 		bool m_WeaponReloadIgnore;
 
-		static const int m_ReleaseDelay; //!< The delay between releasing a menu button and activating the regular controls, to avoid accidental input.
 		Timer m_ReleaseTimer; //!< Timer for measuring release delays.  
 		Timer m_JoyAccelTimer; //!< Timer for measuring analog joystick-controlled cursor acceleration.   
 		Timer m_KeyAccelTimer; //!< Timer for measuring keyboard-controlled cursor acceleration.

System/DataModule.h

@@ -4,15 +4,15 @@
 #include "ContentFile.h"
 #include "Constants.h"
 
-struct DATAFILE;
+//struct DATAFILE; // DataFile loading not implemented.
 struct BITMAP;
 
 namespace RTE {
 
 	class Entity;
 
 	/// <summary>
-	/// A representation of a Data Module containing zero or many Material, Effect, Ammo, Device, Actor, or Scene definitions.
+	/// A representation of a DataModule containing zero or many Material, Effect, Ammo, Device, Actor, or Scene definitions.
 	/// </summary>
 	class DataModule : public Serializable {
 		friend class LuaMan;
@@ -46,7 +46,7 @@ namespace RTE {
 		/// Makes the DataModule object ready for use. This needs to be called after PresetMan is created.
 		/// This looks for an "index.ini" within the specified .rte directory and loads all the defined objects in that index file. 
 		/// </summary>
-		/// <param name="moduleName">A string defining the name of this Data Module, e.g. "MyModule.rte".</param>
+		/// <param name="moduleName">A string defining the name of this DataModule, e.g. "MyModule.rte".</param>
 		/// <param name="fpProgressCallback">A function pointer to a function that will be called and sent a string with information about the progress of this DataModule's creation.</param>
 		/// <returns>An error return value signaling success or any particular failure. Anything below 0 is an error signal.</returns>
 		virtual int Create(std::string moduleName, ProgressCallback fpProgressCallback = 0);
@@ -74,7 +74,7 @@ namespace RTE {
 		/// <summary>
 		/// Read module specific properties from index.ini without processing IncludeFiles and loading the whole module.
 		/// </summary>
-		/// <param name="moduleName">A string defining the name of this Data Module, e.g. "MyModule.rte".</param>
+		/// <param name="moduleName">A string defining the name of this DataModule, e.g. "MyModule.rte".</param>
 		/// <param name="fpProgressCallback">A function pointer to a function that will be called and sent a string with information about the progress of this DataModule's creation.</param>
 		/// <returns>An error return value signaling success or any particular failure. Anything below 0 is an error signal.</returns>
 		virtual int ReadModuleProperties(std::string moduleName, ProgressCallback fpProgressCallback = 0);
@@ -107,37 +107,37 @@ namespace RTE {
 
 #pragma region Module Information Getters
 		/// <summary>
-		/// Gets the file name of this Data Module, e.g. "MyMod.rte".
+		/// Gets the file name of this DataModule, e.g. "MyMod.rte".
 		/// </summary>
 		/// <returns>A string with the data module file name.</returns>
 		virtual const std::string & GetFileName() const { return m_FileName; }
 
 		/// <summary>
-		/// Gets the friendly name of this Data Module, e.g. "My Great Mod".
+		/// Gets the friendly name of this DataModule, e.g. "My Great Mod".
 		/// </summary>
 		/// <returns>A string with the data module's friendly name.</returns>
 		virtual const std::string & GetFriendlyName() const { return m_FriendlyName; }
 
 		/// <summary>
-		/// Gets the author name of this Data Module, e.g. "Data Realms, LLC".
+		/// Gets the author name of this DataModule, e.g. "Data Realms, LLC".
 		/// </summary>
 		/// <returns>A string with the author's name.</returns>
 		virtual const std::string & GetAuthor() const { return m_Author; }
 
 		/// <summary>
-		/// Gets the description of this Data Module's contents.
+		/// Gets the description of this DataModule's contents.
 		/// </summary>
 		/// <returns>A string with the description.</returns>
 		virtual const std::string & GetDescription() const { return m_Description; }
 
 		/// <summary>
-		/// Gets the version number of this Data Module.
+		/// Gets the version number of this DataModule.
 		/// </summary>
 		/// <returns>An int with the version number, starting at 1.</returns>
 		virtual int GetVersionNumber() const { return m_Version; }
 
 		/// <summary>
-		/// Gets the BITMAP that visually represents this Data Module, for use in menus.
+		/// Gets the BITMAP that visually represents this DataModule, for use in menus.
 		/// </summary>
 		/// <returns>BITMAP pointer that might have the icon. 0 is very possible.</returns>
 		BITMAP * GetIcon() const { return m_pIcon; }