feat(radar): Save Radar hidden and forced status for each Player to show correct radar states when switching teams (#1715)

Author: xezon

Core/GameEngine/Include/Common/GameUtility.h

@@ -18,6 +18,8 @@
 
 #pragma once
 
+#include "Lib/BaseType.h"
+
 // For miscellaneous game utility functions.
 
 class Player;
@@ -26,7 +28,8 @@ typedef Int PlayerIndex;
 namespace rts
 {
 
-Bool localPlayerIsObserving();
+bool localPlayerIsObserving();
+bool localPlayerHasRadar();
 Player* getObservedOrLocalPlayer(); ///< Get the current observed or local player. Is never null.
 Player* getObservedOrLocalPlayer_Safe(); ///< Get the current observed or local player. Is never null, except when the application does not have players.
 PlayerIndex getObservedOrLocalPlayerIndex_Safe(); ///< Get the current observed or local player index. Returns 0 when the application does not have players.

Core/GameEngine/Source/Common/GameUtility.cpp

@@ -49,7 +49,7 @@ static void changePlayerCommon(Player* player)
 
 } // namespace detail
 
-Bool localPlayerIsObserving()
+bool localPlayerIsObserving()
 {
 	if (TheGameLogic->isInReplayGame() || TheGameLogic->isInShellGame())
 		return true;
@@ -60,6 +60,22 @@ Bool localPlayerIsObserving()
 	return false;
 }
 
+bool localPlayerHasRadar()
+{
+	// Using "local" instead of "observed or local" player because as an observer we prefer
+	// the radar to be turned on when observing a player that has no radar.
+	const Player* player = ThePlayerList->getLocalPlayer();
+	const PlayerIndex index = player->getPlayerIndex();
+
+	if (TheRadar->isRadarForced(index))
+		return true;
+
+	if (!TheRadar->isRadarHidden(index) && player->hasRadar())
+		return true;
+
+	return false;
+}
+
 Player* getObservedOrLocalPlayer()
 {
 	DEBUG_ASSERTCRASH(TheControlBar != NULL, ("TheControlBar is NULL"));

Generals/Code/GameEngine/Include/Common/Radar.h

@@ -180,9 +180,9 @@ class Radar : public Snapshot,
 	Bool radarToWorld( const ICoord2D *radar, Coord3D *world );		///< radar point to world point on terrain
 	Bool radarToWorld2D( const ICoord2D *radar, Coord3D *world );		///< radar point to world point (x,y only!)
 	Bool worldToRadar( const Coord3D *world, ICoord2D *radar );		///< translate world point to radar (x,y)
-	Bool localPixelToRadar( const ICoord2D *pixel, ICoord2D *radar );	///< translate pixel (with UL of radar being (0,0)) to logical radar coords
+	Bool localPixelToRadar( const ICoord2D *pixel, ICoord2D *radar );	///< translate pixel (with UL of radar being (0,0)) to logical radar coordinates
 	Bool screenPixelToWorld( const ICoord2D *pixel, Coord3D *world ); ///< translate pixel (with UL of the screen being (0,0)) to world position in the world
-	Object *objectUnderRadarPixel( const ICoord2D *pixel );				///< return the object (if any) represented by the pixel coords passed in
+	Object *objectUnderRadarPixel( const ICoord2D *pixel );				///< return the object (if any) represented by the pixel coordinates passed in
 	void findDrawPositions( Int startX, Int startY, Int width, Int height,
 													ICoord2D *ul, ICoord2D *lr );					///< make translation for screen area of radar square to scaled aspect ratio preserving points inside the radar area
 
@@ -203,22 +203,22 @@ class Radar : public Snapshot,
 	virtual RadarObjectType removeObject( Object *obj );								///< remove object from radar
 
 	// radar options
-	void hide( Bool hide ) { m_radarHidden = hide; }				///< hide/unhide the radar
-	Bool isRadarHidden( void ) { return m_radarHidden; }		///< is radar hidden
+	void hide( Int playerIndex, Bool hide ) { m_radarHidden[playerIndex] = hide; } ///< hide/show the radar
+	Bool isRadarHidden( Int playerIndex ) { return m_radarHidden[playerIndex]; } ///< is radar hidden
 	// other radar option methods here like the ability to show a certain
 	// team, show buildings, show units at all, etc
 
 	// forcing the radar on/off regardless of player situation
-	void forceOn( Bool force ) { m_radarForceOn = force; }				///< force the radar to be on
-	Bool isRadarForced( void ) { return m_radarForceOn; }		///< is radar forced on?
+	void forceOn( Int playerIndex, Bool force ) { m_radarForceOn[playerIndex] = force; } ///< force the radar to be on
+	Bool isRadarForced( Int playerIndex ) { return m_radarForceOn[playerIndex]; } ///< is radar forced on?
 
 	/// refresh the water values for the radar
 	virtual void refreshTerrain( TerrainLogic *terrain );
 
 	/// refresh the radar when the state of world objects changes drastically
 	virtual void refreshObjects() {};
 
-	/// queue a refresh of the terran at the next available time
+	/// queue a refresh of the terrain at the next available time
 	virtual void queueTerrainRefresh( void );
 
 	virtual void newMap( TerrainLogic *terrain );	///< reset radar for new map
@@ -252,11 +252,11 @@ class Radar : public Snapshot,
 
 	void clearAllEvents( void );					///< remove all radar events in progress
 
-	// search the object list for an object that maps to the given logical radar coords
+	// search the object list for an object that maps to the given logical radar coordinates
 	Object *searchListForRadarLocationMatch( RadarObject *listHead, ICoord2D *radarMatch );
 
-	Bool m_radarHidden;										///< true when radar is not visible
-	Bool m_radarForceOn;									///< true when radar is forced to be on
+	Bool m_radarHidden[MAX_PLAYER_COUNT]; ///< true when radar is not visible
+	Bool m_radarForceOn[MAX_PLAYER_COUNT]; ///< true when radar is forced to be on
 	RadarObject *m_objectList;						///< list of objects in the radar
 	RadarObject *m_localObjectList;				/** list of objects for the local player, sorted
 																					* in exactly the same priority as the regular

Generals/Code/GameEngine/Source/Common/System/Radar.cpp

@@ -214,8 +214,8 @@ Radar::Radar( void )
 	m_radarWindow = NULL;
 	m_objectList = NULL;
 	m_localObjectList = NULL;
-	m_radarHidden = false;
-	m_radarForceOn = false;
+	std::fill(m_radarHidden, m_radarHidden + ARRAY_SIZE(m_radarHidden), false);
+	std::fill(m_radarForceOn, m_radarForceOn + ARRAY_SIZE(m_radarForceOn), false);
 	m_terrainAverageZ = 0.0f;
 	m_waterAverageZ = 0.0f;
 	m_xSample = 0.0f;
@@ -291,8 +291,11 @@ void Radar::reset( void )
 	// clear all events
 	clearAllEvents();
 
+	// TheSuperHackers @todo Reset m_radarHidden?
+	//std::fill(m_radarHidden, m_radarHidden + ARRAY_SIZE(m_radarHidden), false);
+
 	// stop forcing the radar on
-	m_radarForceOn = false;
+	std::fill(m_radarForceOn, m_radarForceOn + ARRAY_SIZE(m_radarForceOn), false);
 
 }
 
@@ -1484,21 +1487,46 @@ static void xferRadarObjectList( Xfer *xfer, RadarObject **head )
 // ------------------------------------------------------------------------------------------------
 /** Xfer Method
 	* Version Info:
-	* 1: Initial version */
+	* 1: Initial version
+	* 2: TheSuperHackers @tweak Serialize m_radarHidden, m_radarForceOn for each player
+	*/
 // ------------------------------------------------------------------------------------------------
 void Radar::xfer( Xfer *xfer )
 {
 
 	// version
+#if RETAIL_COMPATIBLE_XFER_SAVE
 	XferVersion currentVersion = 1;
+#else
+	XferVersion currentVersion = 2;
+#endif
 	XferVersion version = currentVersion;
 	xfer->xferVersion( &version, currentVersion );
 
-	// radar hidden
-	xfer->xferBool( &m_radarHidden );
 
-	// radar force on
-	xfer->xferBool( &m_radarForceOn );
+	if (version <= 1)
+	{
+		const Int localPlayerIndex = ThePlayerList->getLocalPlayer()->getPlayerIndex();
+		Bool value;
+
+		// radar hidden
+		value = m_radarHidden[localPlayerIndex];
+		xfer->xferBool( &value );
+		m_radarHidden[localPlayerIndex] = value;
+
+		// radar force on
+		value = m_radarForceOn[localPlayerIndex];
+		xfer->xferBool( &value );
+		m_radarForceOn[localPlayerIndex] = value;
+	}
+	else
+	{
+		static_assert(sizeof(m_radarHidden) == 16, "Increase version if size changes");
+		xfer->xferUser(&m_radarHidden, sizeof(m_radarHidden));
+
+		static_assert(sizeof(m_radarForceOn) == 16, "Increase version if size changes");
+		xfer->xferUser(&m_radarForceOn, sizeof(m_radarForceOn));
+	}
 
 	// save our local object list
 	xferRadarObjectList( xfer, &m_localObjectList );

Generals/Code/GameEngine/Source/GameClient/GUI/GUICallbacks/ControlBarCallback.cpp

@@ -31,6 +31,7 @@
 // INCLUDES ///////////////////////////////////////////////////////////////////////////////////////
 #include "PreRTS.h"	// This must go first in EVERY cpp file int the GameEngine
 
+#include "Common/GameUtility.h"
 #include "Common/NameKeyGenerator.h"
 #include "Common/Player.h"
 #include "Common/PlayerList.h"
@@ -64,15 +65,11 @@ WindowLayout *popupCommunicatorLayout = NULL;
 WindowMsgHandledType LeftHUDInput( GameWindow *window, UnsignedInt msg,
 																	 WindowMsgData mData1, WindowMsgData mData2 )
 {
-
-	// get player
-	Player *player = ThePlayerList->getLocalPlayer();
-
 	//
 	// if the player doesn't have a radar, or the radar is hidden, and the radar is not being
 	// forced to on, we just eat input over the radar window
 	//
-	if( !TheRadar->isRadarForced() && (TheRadar->isRadarHidden() || !player->hasRadar()) )
+	if( !rts::localPlayerHasRadar() )
 		return MSG_HANDLED;
 
 	// If the middle mouse button is depressed, then just let the message fall all the
@@ -152,15 +149,14 @@ WindowMsgHandledType LeftHUDInput( GameWindow *window, UnsignedInt msg,
 
 			// is the mouse in the radar window
 			ICoord2D radar;
-			if( (TheRadar->isRadarHidden() == FALSE || TheRadar->isRadarForced()) &&
-					TheRadar->localPixelToRadar( &mouse, &radar ) )
+			if( TheRadar->localPixelToRadar( &mouse, &radar ) )
 			{
 
 /*
 //
 // this is an example piece of code to find the object under the pixel position
 // of the radar ... should we in the future wish to allow commands to be executed
-// on objects throught he radar.  note tho that this is extremely hard to do because
+// on objects through the radar.  note tho that this is extremely hard to do because
 // the pixels on the radar are very small and it's hard to do accurate targeting
 //
 
@@ -252,9 +248,8 @@ WindowMsgHandledType LeftHUDInput( GameWindow *window, UnsignedInt msg,
 			// completely drawn with the radar ... so it's just a translation from
 			// our window size we're drawing into to the radar cell size
 			//
-			if( (TheRadar->isRadarHidden() == FALSE || TheRadar->isRadarForced()) &&
-					TheRadar->localPixelToRadar( &mouse, &radar ) &&
-					TheRadar->radarToWorld( &radar, &world ) )
+			if( TheRadar->localPixelToRadar( &mouse, &radar ) &&
+			    TheRadar->radarToWorld( &radar, &world ) )
 			{
 
 				// No drawables, or a right click automatically means its a look at.

Generals/Code/GameEngine/Source/GameClient/InGameUI.cpp

@@ -1356,13 +1356,7 @@ void InGameUI::handleRadiusCursor()
 		// from screen to world
 		// But only if the radar is on.
 		//
-		Bool radarOn = TheRadar->isRadarForced()
-									|| ( !TheRadar->isRadarHidden()
-												&& ThePlayerList->getLocalPlayer()
-												&& ThePlayerList->getLocalPlayer()->hasRadar()
-											);
-
-		if( !radarOn  ||  (TheRadar->screenPixelToWorld( &mouseIO->pos, &pos ) == FALSE) )// if radar off, or point not on radar
+		if( !rts::localPlayerHasRadar()  ||  (TheRadar->screenPixelToWorld( &mouseIO->pos, &pos ) == FALSE) )// if radar off, or point not on radar
 			TheTacticalView->screenToTerrain( &mouseIO->pos, &pos );
 
 		m_curRadiusCursor.setPosition(pos);	//world space position of center of decal
@@ -2693,10 +2687,7 @@ void InGameUI::createCommandHint( const GameMessage *msg )
 							setMouseCursor( Mouse::GENERIC_INVALID );
 						else if( drawSelectable && obj->isLocallyControlled() && !obj->isKindOf(KINDOF_MINE))
 							setMouseCursor( Mouse::SELECTING );
-						else if( TheRadar->isRadarWindow( window ) &&
-										 TheRadar->isRadarForced() == FALSE &&
-										 (TheRadar->isRadarHidden() ||
-										 ThePlayerList->getLocalPlayer()->hasRadar() == FALSE) )
+						else if( TheRadar->isRadarWindow( window ) && !rts::localPlayerHasRadar() )
 							setMouseCursor( Mouse::ARROW );
 						else
 							setMouseCursor( Mouse::MOVETO );

Generals/Code/GameEngine/Source/GameClient/MessageStream/CommandXlat.cpp

@@ -2876,18 +2876,11 @@ GameMessageDisposition CommandTranslator::translateGameMessage(const GameMessage
 		//-----------------------------------------------------------------------------------------
 		case GameMessage::MSG_META_VIEW_LAST_RADAR_EVENT:
 		{
-//			Player *player = ThePlayerList->getLocalPlayer();
+			// You don't need radar for the space bar. That's silly.
+			Coord3D lastEvent;
 
-			// if the local player has a radar, center on last event (if any)
-			// Excuse me?  You don't need radar for the spacebar.  That's silly.
-//			if( TheRadar->isRadarForced() || ( TheRadar->isRadarHidden() == false && player->hasRadar() ) )
-			{
-				Coord3D lastEvent;
-
-				if( TheRadar->getLastEventLoc( &lastEvent ) )
-					TheTacticalView->lookAt( &lastEvent );
-
-			}
+			if( TheRadar->getLastEventLoc( &lastEvent ) )
+				TheTacticalView->lookAt( &lastEvent );
 
 			disp = DESTROY_MESSAGE;
 			break;

Generals/Code/GameEngine/Source/GameLogic/ScriptEngine/ScriptActions.cpp

@@ -2874,15 +2874,15 @@ void ScriptActions::doTeamRadarCreateEvent(const AsciiString& teamName, Int even
 //-------------------------------------------------------------------------------------------------
 void ScriptActions::doRadarDisable(void)
 {
-	TheRadar->hide(true);
+	TheRadar->hide(ThePlayerList->getLocalPlayer()->getPlayerIndex(), true);
 }
 
 //-------------------------------------------------------------------------------------------------
 /** doRadarEnable */
 //-------------------------------------------------------------------------------------------------
 void ScriptActions::doRadarEnable(void)
 {
-	TheRadar->hide(false);
+	TheRadar->hide(ThePlayerList->getLocalPlayer()->getPlayerIndex(), false);
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -4789,15 +4789,15 @@ void ScriptActions::doDestroyAllContained(const AsciiString& unitName, Int damag
 //-------------------------------------------------------------------------------------------------
 void ScriptActions::doRadarForceEnable(void)
 {
-	TheRadar->forceOn(true);
+	TheRadar->forceOn(ThePlayerList->getLocalPlayer()->getPlayerIndex(), true);
 }
 
 //-------------------------------------------------------------------------------------------------
 /** doRadarRevertNormal */
 //-------------------------------------------------------------------------------------------------
 void ScriptActions::doRadarRevertNormal(void)
 {
-	TheRadar->forceOn(false);
+	TheRadar->forceOn(ThePlayerList->getLocalPlayer()->getPlayerIndex(), false);
 }
 
 //-------------------------------------------------------------------------------------------------

Generals/Code/GameEngine/Source/GameLogic/ScriptEngine/VictoryConditions.cpp

@@ -32,6 +32,7 @@
 #include "Common/GameAudio.h"
 #include "Common/GameCommon.h"
 #include "Common/GameEngine.h"
+#include "Common/GameUtility.h"
 #include "Common/KindOf.h"
 #include "Common/PlayerList.h"
 #include "Common/Player.h"
@@ -140,7 +141,7 @@ void VictoryConditions::reset( void )
 //-------------------------------------------------------------------------------------------------
 void VictoryConditions::update( void )
 {
-	if (!TheRecorder->isMultiplayer() || (m_localSlotNum == -1 && !m_isObserver))
+	if (!TheRecorder->isMultiplayer() || (m_localSlotNum < 0 && !m_isObserver))
 		return;
 
 	// Check for a single winning alliance
@@ -226,7 +227,7 @@ void VictoryConditions::update( void )
 				//MessageBoxOk(TheGameText->fetch("GUI:Defeat"), TheGameText->fetch("GUI:LocalDefeat"), NULL);
 			}
 			m_localPlayerDefeated = true;	// don't check again
-			TheRadar->forceOn(TRUE);
+			TheRadar->forceOn(localPlayer->getPlayerIndex(), TRUE);
 			SetInGameChatType( INGAME_CHAT_EVERYONE ); // can't chat to allies after death.  Only to other observers.
 		}
 	}
@@ -326,8 +327,6 @@ void VictoryConditions::cachePlayerPtrs( void )
 	if (m_localSlotNum < 0)
 	{
 		m_localPlayerDefeated = true;	// if we have no local player, don't check for defeat
-		DEBUG_ASSERTCRASH(TheRadar, ("No Radar!"));
-		TheRadar->forceOn(TRUE);
 		m_isObserver = true;
 	}
 }