Added complete retail incompatible version.

Author: Caball009

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

@@ -66,7 +66,11 @@ class TunnelTracker : public MemoryPoolObject,
 	void healObjects();	///< heal all objects within the tunnel
 #endif
 
+#if RETAIL_COMPATIBLE_CRC
 	Bool isLastTunnel() const {return m_tunnelCount == 1;}///< TunnelContains are allowed to ask if they are the last one ahead of deletion time
+#else
+	Bool isLastTunnel() const { return m_tunnelIDs.size() == 1; }///< TunnelContains are allowed to ask if they are the last one ahead of deletion time
+#endif
 
 	const std::list< ObjectID > *getContainerList() const {return &m_tunnelIDs;}
 
@@ -87,7 +91,9 @@ class TunnelTracker : public MemoryPoolObject,
 	std::list< ObjectID > m_xferContainList;///< for loading of m_containList during post processing
 	Int m_containListSize;									///< size of the contain list
 	UnsignedInt m_heroUnitsContained;				///< cached hero count
+#if RETAIL_COMPATIBLE_CRC
 	UnsignedInt m_tunnelCount;							///< How many tunnels have registered so we know when we should kill our contain list
+#endif
 	UnsignedInt m_framesForFullHeal;				///< How many frames it takes to fully heal a unit
 	Bool m_needsFullHealTimeUpdate;					///< Set to true when needing to recalc full heal time to batch the operation
 

GeneralsMD/Code/GameEngine/Source/Common/RTS/TunnelTracker.cpp

@@ -50,7 +50,9 @@
 // ------------------------------------------------------------------------
 TunnelTracker::TunnelTracker()
 {
+#if RETAIL_COMPATIBLE_CRC
 	m_tunnelCount = 0;
+#endif
 	m_containListSize = 0;
 	m_heroUnitsContained = 0;
 	m_curNemesisID = INVALID_ID;
@@ -224,21 +226,32 @@ Bool TunnelTracker::isInContainer( Object *obj )
 // ------------------------------------------------------------------------
 void TunnelTracker::onTunnelCreated( const Object *newTunnel )
 {
+	DEBUG_ASSERTCRASH(std::find(m_tunnelIDs.begin(), m_tunnelIDs.end(), newTunnel->getID()) == m_tunnelIDs.end(),
+		("TunnelTracker::onTunnelCreated - New tunnel was already added; this shouldn't happen"));
+
+#if RETAIL_COMPATIBLE_CRC
 	m_tunnelCount++;
+#endif
 	m_tunnelIDs.push_back( newTunnel->getID() );
 	m_needsFullHealTimeUpdate = true;
 }
 
 // ------------------------------------------------------------------------
 void TunnelTracker::onTunnelDestroyed( const Object *deadTunnel )
 {
+#if RETAIL_COMPATIBLE_CRC
+
 	DEBUG_ASSERTCRASH(static_cast<Int>(m_tunnelCount) > 0 && m_tunnelCount == m_tunnelIDs.size(),
 		("TunnelTracker::onTunnelDestroyed - Tunnel count is unexpected"));
-	DEBUG_ASSERTCRASH(std::find(m_tunnelIDs.begin(), m_tunnelIDs.end(), deadTunnel->getID()) != m_tunnelIDs.end(),
+
+	const size_t oldSize = m_tunnelIDs.size();
+	m_tunnelIDs.remove(deadTunnel->getID());
+
+	static_cast<void>(oldSize);
+	DEBUG_ASSERTCRASH(oldSize != m_tunnelIDs.size(),
 		("TunnelTracker::onTunnelDestroyed - Attempting to remove object '%s' that has never been tracked as a tunnel", deadTunnel->getName().str()));
 
 	m_tunnelCount--;
-	m_tunnelIDs.remove( deadTunnel->getID() );
 	m_needsFullHealTimeUpdate = true;
 
 	if( m_tunnelCount == 0 )
@@ -265,6 +278,48 @@ void TunnelTracker::onTunnelDestroyed( const Object *deadTunnel )
 				obj->onContainedBy( tunnel );
 		}
 	}
+
+#else
+
+	const std::list<ObjectID>::iterator it = std::find(m_tunnelIDs.begin(), m_tunnelIDs.end(), deadTunnel->getID());
+	if (it == m_tunnelIDs.end())
+	{
+		DEBUG_CRASH(("TunnelTracker::onTunnelDestroyed - Attempting to remove object '%s' that has never been tracked as a tunnel",
+			deadTunnel->getName().str()));
+	}
+	else
+	{
+		DEBUG_ASSERTCRASH(std::find(std::next(it), m_tunnelIDs.end(), deadTunnel->getID()) == m_tunnelIDs.end(),
+			("TunnelTracker::onTunnelDestroyed - Tunnel should have been tracked only once"));
+
+		m_tunnelIDs.erase(it);
+	}
+
+	m_needsFullHealTimeUpdate = true;
+
+	if( m_tunnelIDs.empty() )
+	{
+		// Kill everyone in our contain list.  Cave in!
+		iterateContained( destroyObject, nullptr, FALSE );
+		m_containList.clear();
+		m_containListSize = 0;
+	}
+	else
+	{
+		Object *validTunnel = TheGameLogic->findObjectByID( m_tunnelIDs.front() );
+
+		// Otherwise, make sure nobody inside remembers the dead tunnel as the one they entered
+		// (scripts need to use so there must be something valid here)
+		for(ContainedItemsList::iterator it = m_containList.begin(); it != m_containList.end(); )
+		{
+			Object* obj = *it;
+			++it;
+			if( obj->getContainedBy() == deadTunnel )
+				obj->onContainedBy( validTunnel );
+		}
+	}
+
+#endif // RETAIL_COMPATIBLE_CRC
 }
 
 // ------------------------------------------------------------------------
@@ -379,13 +434,19 @@ void TunnelTracker::crc( Xfer *xfer )
 // ------------------------------------------------------------------------------------------------
 /** Xfer method
 	* Version Info:
-	* 1: Initial version */
+	* 1: Initial version
+	* 2: TheSuperHackers @tweak Removed m_tunnelCount (should always be equal to m_tunnelIDs.size())
+	*/
 // ------------------------------------------------------------------------------------------------
 void TunnelTracker::xfer( Xfer *xfer )
 {
 
 	// version
+#if RETAIL_COMPATIBLE_XFER_SAVE
 	XferVersion currentVersion = 1;
+#else
+	XferVersion currentVersion = 2;
+#endif
 	XferVersion version = currentVersion;
 	xfer->xferVersion( &version, currentVersion );
 
@@ -424,8 +485,22 @@ void TunnelTracker::xfer( Xfer *xfer )
 		m_needsFullHealTimeUpdate = true;
 	}
 
-	// tunnel count
-	xfer->xferUnsignedInt( &m_tunnelCount );
+#if RETAIL_COMPATIBLE_CRC
+	if (version <= 1)
+	{
+		xfer->xferUnsignedInt(&m_tunnelCount);
+	}
+	else
+	{
+		m_tunnelCount = m_tunnelIDs.size();
+	}
+#else
+	if (version <= 1)
+	{
+		UnsignedInt tunnelCount = m_tunnelIDs.size();
+		xfer->xferUnsignedInt(&tunnelCount);
+	}
+#endif
 
 }