- Added support for "host wants to start"

x64-dev · x64-dev · commit 72eabcec4d6c · 2025-04-15T21:13:55.000-04:00
- Improved "Host wants to start" by automatically readying everyone up 30 seconds later
diff --git a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
@@ -208,6 +208,7 @@ class NGMP_OnlineServicesManager
 
 	std::string& GetMOTD() { return m_strMOTD; }
 
+
 private:
 	//EOS_HPlatform m_EOSPlatformHandle = nullptr;
 
diff --git a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_LobbyInterface.h b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_LobbyInterface.h
@@ -76,6 +76,8 @@ class NGMP_OnlineServices_LobbyInterface
 	void UpdateCurrentLobby_MyStartPos(int side);
 	void UpdateCurrentLobby_MyTeam(int side);
 
+	void UpdateCurrentLobby_ForceReady();
+
 	void SetLobbyListDirty()
 	{
 		m_bLobbyListDirty = true;
@@ -110,6 +112,7 @@ class NGMP_OnlineServices_LobbyInterface
 	AsciiString GetCurrentLobbyMapPath();
 
 	void SendChatMessageToCurrentLobby(UnicodeString& strChatMsgUnicode);
+	void SendAnnouncementMessageToCurrentLobby(UnicodeString& strAnnouncementMsgUnicode, bool bShowToHost);
 
 	void InvokeCreateLobbyCallback(bool bSuccess)
 	{
@@ -164,6 +167,20 @@ class NGMP_OnlineServices_LobbyInterface
 				//UpdateRoomDataCache();
 				m_lastForceRefresh = currTime;
 			}
+
+			// do we have a pending start?
+			if (IsHost())
+			{
+				if (m_timeStartAutoReadyCountdown > 0)
+				{
+					if ((currTime - m_timeStartAutoReadyCountdown) > 30000)
+					{
+						// TODO_NGMP: Don't do this clientside...
+						UpdateCurrentLobby_ForceReady();
+						ClearAutoReadyCountdown();
+					}
+				}
+			}
 		}
 	}
 
@@ -277,6 +294,21 @@ class NGMP_OnlineServices_LobbyInterface
 	bool m_bHostMigrated = false;
 	bool m_bPendingHostHasLeft = false;
 
+	void StartAutoReadyCountdown()
+	{
+		m_timeStartAutoReadyCountdown = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::utc_clock::now().time_since_epoch()).count();
+	}
+
+	void ClearAutoReadyCountdown()
+	{
+		m_timeStartAutoReadyCountdown = -1;
+	}
+
+	bool HasAutoReadyCountdown()
+	{
+		return m_timeStartAutoReadyCountdown != -1;
+	}
+
 private:
 	std::vector<std::function<void(bool)>> m_vecCreateLobby_PendingCallbacks = std::vector<std::function<void(bool)>>();
 
@@ -290,4 +322,6 @@ class NGMP_OnlineServices_LobbyInterface
 	NGMPGame* m_pGameInst = nullptr;
 
 	bool m_bLobbyListDirty = false;
+
+	int64_t m_timeStartAutoReadyCountdown = -1;
 };
diff --git a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/Packets/NetworkPacket_NetRoom_ChatMessage.h b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/Packets/NetworkPacket_NetRoom_ChatMessage.h
@@ -5,14 +5,18 @@
 class NetRoom_ChatMessagePacket : public NetworkPacket
 {
 public:
-	NetRoom_ChatMessagePacket(AsciiString& strMessage);
+	NetRoom_ChatMessagePacket(AsciiString& strMessage, bool bIsAnnouncement, bool bShowAnnounceToHost);
 
 	NetRoom_ChatMessagePacket(CBitStream& bitstream);
 
 	virtual CBitStream* Serialize() override;
 
 	const std::string& GetMsg() const { return m_strMessage; }
+	bool IsAnnouncement() const { return m_bIsAnnouncement; }
+	bool ShowAnnouncementToHost() const { return m_bShowAnnounceToHost; }
 
 private:
 	std::string m_strMessage = "";
+	bool m_bIsAnnouncement = false;
+	bool m_bShowAnnounceToHost = false;
 };
diff --git a/GeneralsMD/Code/GameEngine/Source/GameClient/GUI/GUICallbacks/Menus/WOLGameSetupMenu.cpp b/GeneralsMD/Code/GameEngine/Source/GameClient/GUI/GUICallbacks/Menus/WOLGameSetupMenu.cpp
@@ -890,6 +890,9 @@ static void StartPressed(void)
 
 	if(isReady)
 	{
+		// reset autostart just incase
+		NGMP_OnlineServicesManager::GetInstance()->GetLobbyInterface()->ClearAutoReadyCountdown();
+
 		//PeerRequest req;
 		//req.peerRequestType = PeerRequest::PEERREQUEST_STARTGAME;
 		//TheGameSpyPeerMessageQueue->addRequest(req);
@@ -913,18 +916,35 @@ static void StartPressed(void)
 	}
 	else if (allHaveMap)
 	{
-		// TODO_NGMP: today
-		GadgetListBoxAddEntryText(listboxGameSetupChat, TheGameText->fetch("GUI:NotifiedStartIntent"), GameSpyColor[GSCOLOR_DEFAULT], -1, -1);
-		PeerRequest req;
-		req.peerRequestType = PeerRequest::PEERREQUEST_UTMROOM;
-		req.UTM.isStagingRoom = TRUE;
-		req.id = "HWS/";
-		req.options = "true";
-		TheGameSpyPeerMessageQueue->addRequest(req);
+		// send HWS chat message
+		
+		if (!NGMP_OnlineServicesManager::GetInstance()->GetLobbyInterface()->HasAutoReadyCountdown())
+		{
+			// local msg
+			GadgetListBoxAddEntryText(listboxGameSetupChat, TheGameText->fetch("GUI:NotifiedStartIntent"), GameSpyColor[GSCOLOR_DEFAULT], -1, -1);
+
+			// remote msg
+			UnicodeString strInform = TheGameText->fetch("GUI:HostWantsToStart");
+			UnicodeString strInform2 = UnicodeString(L"All players will be forced to ready up in 30 seconds");
+			NGMP_OnlineServicesManager::GetInstance()->GetLobbyInterface()->SendAnnouncementMessageToCurrentLobby(strInform, false);
+			NGMP_OnlineServicesManager::GetInstance()->GetLobbyInterface()->SendAnnouncementMessageToCurrentLobby(strInform2, true);
+
+			// TODO_NGMP: Add the reverse too, if everyone is ready but the host wont start... just start it in X seconds
+
+			// start a countdown to auto start
+			// TODO_NGMP: Don't have this client driven...
+			NGMP_OnlineServicesManager::GetInstance()->GetLobbyInterface()->StartAutoReadyCountdown();
+		}
+		else
+		{
+			UnicodeString strInform = UnicodeString(L"You have already informed players you want to start. A countdown has begun after which they will be marked as ready.");
+			GadgetListBoxAddEntryText(listboxGameSetupChat, strInform, GameSpyColor[GSCOLOR_DEFAULT], -1, -1);
+		}
 	}
 
 }//void StartPressed(void)
 
+
 //-------------------------------------------------------------------------------------------------
 /** Update options on screen */
 //-------------------------------------------------------------------------------------------------
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NetworkMesh.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NetworkMesh.cpp
@@ -422,6 +422,9 @@ void NetworkMesh::Tick()
 						// TODO_NGMP: Support longer msgs
 						NetworkLog("[NGMP]: Received chat message of len %d: %s from %d", chatPacket.GetMsg().length(), chatPacket.GetMsg().c_str(), event.peer->incomingPeerID);
 
+						// get host ID
+						int64_t localID = NGMP_OnlineServicesManager::GetInstance()->GetAuthInterface()->GetUserID();
+
 						// find user
 						for (auto& connectionData : m_mapConnections)
 						{
@@ -433,9 +436,24 @@ void NetworkMesh::Tick()
 								{
 									if (lobbyUser.user_id == connectionData.first)
 									{
-										UnicodeString str;
-										str.format(L"%hs: %hs", lobbyUser.display_name.c_str(), chatPacket.GetMsg().c_str());
-										NGMP_OnlineServicesManager::GetInstance()->GetLobbyInterface()->m_OnChatCallback(str);
+										// if its an announce, dont show it to the sender, they did something locally instead
+										if (chatPacket.IsAnnouncement())
+										{
+											// if its not us, show the message
+											if (chatPacket.ShowAnnouncementToHost() || lobbyUser.user_id != localID)
+											{
+												UnicodeString str;
+												str.format(L"%hs", chatPacket.GetMsg().c_str());
+												NGMP_OnlineServicesManager::GetInstance()->GetLobbyInterface()->m_OnChatCallback(str);
+											}
+										}
+										else
+										{
+											UnicodeString str;
+											str.format(L"%hs: %hs", lobbyUser.display_name.c_str(), chatPacket.GetMsg().c_str());
+											NGMP_OnlineServicesManager::GetInstance()->GetLobbyInterface()->m_OnChatCallback(str);
+										}
+										
 
 										break;
 									}
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_LobbyInterface.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_LobbyInterface.cpp
@@ -52,11 +52,15 @@ enum class ELobbyUpdateField
 	MY_START_POS = 3,
 	MY_TEAM = 4,
 	LOBBY_STARTING_CASH = 5,
-	LOBBY_LIMIT_SUPERWEAPONS = 6 
+	LOBBY_LIMIT_SUPERWEAPONS = 6,
+	HOST_ACTION_FORCE_START = 7
 };
 
 void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_Map(AsciiString strMap, AsciiString strMapPath, int newMaxPlayers)
 {
+	// reset autostart if host changes anything (because ready flag will reset too)
+	ClearAutoReadyCountdown();
+
 	std::string strURI = std::format("{}/{}", NGMP_OnlineServicesManager::GetAPIEndpoint("Lobby", true), m_CurrentLobby.lobbyID);
 	std::map<std::string, std::string> mapHeaders;
 
@@ -76,6 +80,9 @@ void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_Map(AsciiString strM
 
 void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_LimitSuperweapons(bool bLimitSuperweapons)
 {
+	// reset autostart if host changes anything (because ready flag will reset too)
+	ClearAutoReadyCountdown();
+
 	std::string strURI = std::format("{}/{}", NGMP_OnlineServicesManager::GetAPIEndpoint("Lobby", true), m_CurrentLobby.lobbyID);
 	std::map<std::string, std::string> mapHeaders;
 
@@ -93,6 +100,9 @@ void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_LimitSuperweapons(bo
 
 void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_StartingCash(UnsignedInt startingCashValue)
 {
+	// reset autostart if host changes anything (because ready flag will reset too)
+	ClearAutoReadyCountdown();
+
 	std::string strURI = std::format("{}/{}", NGMP_OnlineServicesManager::GetAPIEndpoint("Lobby", true), m_CurrentLobby.lobbyID);
 	std::map<std::string, std::string> mapHeaders;
 
@@ -110,6 +120,9 @@ void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_StartingCash(Unsigne
 
 void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_MySide(int side, int updatedStartPos)
 {
+	// reset autostart if host changes anything (because ready flag will reset too). This occurs on client too, but nothing happens for them
+	ClearAutoReadyCountdown();
+
 	std::string strURI = std::format("{}/{}", NGMP_OnlineServicesManager::GetAPIEndpoint("Lobby", true), m_CurrentLobby.lobbyID);
 	std::map<std::string, std::string> mapHeaders;
 
@@ -128,6 +141,9 @@ void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_MySide(int side, int
 
 void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_MyColor(int color)
 {
+	// reset autostart if host changes anything (because ready flag will reset too). This occurs on client too, but nothing happens for them
+	ClearAutoReadyCountdown();
+
 	std::string strURI = std::format("{}/{}", NGMP_OnlineServicesManager::GetAPIEndpoint("Lobby", true), m_CurrentLobby.lobbyID);
 	std::map<std::string, std::string> mapHeaders;
 
@@ -145,6 +161,9 @@ void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_MyColor(int color)
 
 void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_MyStartPos(int startpos)
 {
+	// reset autostart if host changes anything (because ready flag will reset too). This occurs on client too, but nothing happens for them
+	ClearAutoReadyCountdown();
+
 	std::string strURI = std::format("{}/{}", NGMP_OnlineServicesManager::GetAPIEndpoint("Lobby", true), m_CurrentLobby.lobbyID);
 	std::map<std::string, std::string> mapHeaders;
 
@@ -162,6 +181,9 @@ void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_MyStartPos(int start
 
 void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_MyTeam(int team)
 {
+	// reset autostart if host changes anything (because ready flag will reset too). This occurs on client too, but nothing happens for them
+	ClearAutoReadyCountdown();
+
 	std::string strURI = std::format("{}/{}", NGMP_OnlineServicesManager::GetAPIEndpoint("Lobby", true), m_CurrentLobby.lobbyID);
 	std::map<std::string, std::string> mapHeaders;
 
@@ -177,14 +199,31 @@ void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_MyTeam(int team)
 		});
 }
 
+void NGMP_OnlineServices_LobbyInterface::UpdateCurrentLobby_ForceReady()
+{
+	std::string strURI = std::format("{}/{}", NGMP_OnlineServicesManager::GetAPIEndpoint("Lobby", true), m_CurrentLobby.lobbyID);
+	std::map<std::string, std::string> mapHeaders;
+
+	nlohmann::json j;
+	j["field"] = ELobbyUpdateField::HOST_ACTION_FORCE_START;
+	std::string strPostData = j.dump();
+
+	// convert
+	NGMP_OnlineServicesManager::GetInstance()->GetHTTPManager()->SendPOSTRequest(strURI.c_str(), EIPProtocolVersion::DONT_CARE, mapHeaders, strPostData.c_str(), [=](bool bSuccess, int statusCode, std::string strBody)
+		{
+			UnicodeString msg = UnicodeString(L"All players have been forced to ready up.");
+			SendAnnouncementMessageToCurrentLobby(msg, true);
+		});
+}
+
 void NGMP_OnlineServices_LobbyInterface::SendChatMessageToCurrentLobby(UnicodeString& strChatMsgUnicode)
 {
 	// TODO_NGMP: Custom
 	// TODO_NGMP: Support unicode again
 	AsciiString strChatMsg;
 	strChatMsg.translate(strChatMsgUnicode);
 
-	NetRoom_ChatMessagePacket chatPacket(strChatMsg);
+	NetRoom_ChatMessagePacket chatPacket(strChatMsg, false, false);
 
 	// TODO_NGMP: Move to uint64 for user id
 	std::vector<int64_t> vecUsersToSend;
@@ -199,6 +238,21 @@ void NGMP_OnlineServices_LobbyInterface::SendChatMessageToCurrentLobby(UnicodeSt
 	}
 }
 
+// TODO_NGMP: Just send a separate packet for each announce, more efficient and less hacky
+void NGMP_OnlineServices_LobbyInterface::SendAnnouncementMessageToCurrentLobby(UnicodeString& strAnnouncementMsgUnicode, bool bShowToHost)
+{
+	AsciiString strChatMsg;
+	strChatMsg.translate(strAnnouncementMsgUnicode);
+
+	NetRoom_ChatMessagePacket chatPacket(strChatMsg, true, bShowToHost);
+
+	std::vector<int64_t> vecUsersToSend;
+	if (m_pLobbyMesh != nullptr)
+	{
+		m_pLobbyMesh->SendToMesh(chatPacket, vecUsersToSend);
+	}
+}
+
 NGMP_OnlineServices_LobbyInterface::NGMP_OnlineServices_LobbyInterface()
 {
 	/*
@@ -825,6 +879,8 @@ void NGMP_OnlineServices_LobbyInterface::JoinLobby(int index)
 
 void NGMP_OnlineServices_LobbyInterface::LeaveCurrentLobby()
 {
+	m_timeStartAutoReadyCountdown = -1;
+
 	// kill mesh
 	if (m_pLobbyMesh != nullptr)
 	{
@@ -1180,6 +1236,9 @@ void NGMP_OnlineServices_LobbyInterface::CreateLobby(UnicodeString strLobbyName,
 
 void NGMP_OnlineServices_LobbyInterface::OnJoinedOrCreatedLobby(bool bAlreadyUpdatedDetails)
 {
+	// reset timer
+	m_timeStartAutoReadyCountdown = -1;
+
 	// TODO_NGMP: We need this on create, but this is a double call on join because we already got this info
 	// must be done in a callback, this is an async function
 	if (!bAlreadyUpdatedDetails)
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/Packets/NetworkPacket_NetRoom_ChatMessage.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/Packets/NetworkPacket_NetRoom_ChatMessage.cpp
@@ -1,19 +1,25 @@
 #include "GameNetwork/GeneralsOnline/NetworkPacket.h"
 #include "GameNetwork/GeneralsOnline/Packets/NetworkPacket_NetRoom_ChatMessage.h"
 
-NetRoom_ChatMessagePacket::NetRoom_ChatMessagePacket(AsciiString& strMessage) : NetworkPacket(EPacketReliability::PACKET_RELIABILITY_RELIABLE_ORDERED)
+NetRoom_ChatMessagePacket::NetRoom_ChatMessagePacket(AsciiString& strMessage, bool bIsAnnouncement, bool bShowAnnounceToHost) : NetworkPacket(EPacketReliability::PACKET_RELIABILITY_RELIABLE_ORDERED)
 {
 	m_strMessage = strMessage.str();
+	m_bIsAnnouncement = bIsAnnouncement;
+	m_bShowAnnounceToHost = bShowAnnounceToHost;
 }
 
 NetRoom_ChatMessagePacket::NetRoom_ChatMessagePacket(CBitStream& bitstream) : NetworkPacket(bitstream)
 {
 	m_strMessage = bitstream.ReadString();
+	m_bIsAnnouncement = bitstream.Read<bool>();
+	m_bShowAnnounceToHost = bitstream.Read<bool>();
 }
 
 CBitStream* NetRoom_ChatMessagePacket::Serialize()
 {
 	CBitStream* pBitstream = new CBitStream(EPacketID::PACKET_ID_NET_ROOM_CHAT_MSG);
 	pBitstream->WriteString(m_strMessage.c_str());
+	pBitstream->Write<bool>(m_bIsAnnouncement);
+	pBitstream->Write<bool>(m_bShowAnnounceToHost);
 	return pBitstream;
 }

Original file line number	Diff line number	Diff line change
`@@ -1,19 +1,25 @@`
`1`	`1`	`#include "GameNetwork/GeneralsOnline/NetworkPacket.h"`
`2`	`2`	`#include "GameNetwork/GeneralsOnline/Packets/NetworkPacket_NetRoom_ChatMessage.h"`
`3`	`3`
`4`		`-NetRoom_ChatMessagePacket::NetRoom_ChatMessagePacket(AsciiString& strMessage) : NetworkPacket(EPacketReliability::PACKET_RELIABILITY_RELIABLE_ORDERED)`
	`4`	`+NetRoom_ChatMessagePacket::NetRoom_ChatMessagePacket(AsciiString& strMessage, bool bIsAnnouncement, bool bShowAnnounceToHost) : NetworkPacket(EPacketReliability::PACKET_RELIABILITY_RELIABLE_ORDERED)`
`5`	`5`	`{`
`6`	`6`	`m_strMessage = strMessage.str();`
	`7`	`+ m_bIsAnnouncement = bIsAnnouncement;`
	`8`	`+ m_bShowAnnounceToHost = bShowAnnounceToHost;`
`7`	`9`	`}`
`8`	`10`
`9`	`11`	`NetRoom_ChatMessagePacket::NetRoom_ChatMessagePacket(CBitStream& bitstream) : NetworkPacket(bitstream)`
`10`	`12`	`{`
`11`	`13`	`m_strMessage = bitstream.ReadString();`
	`14`	`+ m_bIsAnnouncement = bitstream.Read<bool>();`
	`15`	`+ m_bShowAnnounceToHost = bitstream.Read<bool>();`
`12`	`16`	`}`
`13`	`17`
`14`	`18`	`CBitStream* NetRoom_ChatMessagePacket::Serialize()`
`15`	`19`	`{`
`16`	`20`	`CBitStream* pBitstream = new CBitStream(EPacketID::PACKET_ID_NET_ROOM_CHAT_MSG);`
`17`	`21`	`pBitstream->WriteString(m_strMessage.c_str());`
	`22`	`+ pBitstream->Write<bool>(m_bIsAnnouncement);`
	`23`	`+ pBitstream->Write<bool>(m_bShowAnnounceToHost);`
`18`	`24`	`return pBitstream;`
`19`	`25`	`}`