CAreaPortalOneWay

// An areaportal that automatically closes and opens depending on the direction of the client.
// http://developer.valvesoftware.com/wiki/CAreaPortalOneWay
class CAreaPortalOneWay : public CAreaPortal // CAPOW!
{
	DECLARE_CLASS( CAreaPortalOneWay, CAreaPortal );
	DECLARE_DATADESC();
 
public:
	Vector	 m_vecOpenVector;
	bool	 m_bAvoidPop;
	bool	 m_bOneWayActive;
 
	void Spawn();
	void Activate();
	int  Restore(IRestore &restore);
	bool UpdateVisibility( const Vector &vOrigin, float fovDistanceAdjustFactor, bool &bIsOpenOnClient );
 
	void InputDisableOneWay( inputdata_t &inputdata );
	void InputEnableOneWay( inputdata_t &inputdata );
	void InputToggleOneWay( inputdata_t &inputdata );
	void InputInvertOneWay( inputdata_t &inputdata );
 
protected:
	void RemoteUpdate( bool IsOpen );
 
	bool m_bRemotelyUpdated;
	bool m_bRemoteCalcWasOpen;
	CHandle<CAreaPortalOneWay> m_hNextPortal; // This get saved to disc...
	CAreaPortalOneWay* m_pNextPortal; // ...while this gets used at runtime, avoiding loads of casts
 
private:
	void UpdateNextPortal( bool IsOpen );
 
	// These two are irrelevant once the entity has established itself
	string_t m_strGroupName;
	Vector	 m_vecOrigin_; // The portal won't compile properly if vecOrigin itself has a value, but it's okay to move something in at runtime
};
 
LINK_ENTITY_TO_CLASS( func_areaportal_oneway, CAreaPortalOneWay );
 
BEGIN_DATADESC( CAreaPortalOneWay )
	DEFINE_KEYFIELD( m_vecOpenVector, FIELD_VECTOR, "onewayfacing" ),
	DEFINE_KEYFIELD( m_bAvoidPop, FIELD_BOOLEAN, "avoidpop" ),
	DEFINE_KEYFIELD_NOT_SAVED( m_vecOrigin_, FIELD_VECTOR, "origin_" ),
	DEFINE_KEYFIELD_NOT_SAVED( m_strGroupName, FIELD_STRING, "group" ),
	DEFINE_FIELD( m_bOneWayActive, FIELD_BOOLEAN ),
	DEFINE_FIELD( m_hNextPortal, FIELD_EHANDLE ),
	DEFINE_INPUTFUNC( FIELD_VOID, "DisableOneWay", InputDisableOneWay ),
	DEFINE_INPUTFUNC( FIELD_VOID, "EnableOneWay", InputEnableOneWay ),
	DEFINE_INPUTFUNC( FIELD_VOID, "ToggleOneWay", InputToggleOneWay ),
	DEFINE_INPUTFUNC( FIELD_VOID, "InvertOneWay", InputInvertOneWay ),
END_DATADESC()
 
void CAreaPortalOneWay::Spawn()
{
	// Convert our angle from Hammer to a proper vector
	QAngle angOpenDir = QAngle( m_vecOpenVector.x, m_vecOpenVector.y, m_vecOpenVector.z );
	AngleVectors( angOpenDir, &m_vecOpenVector );
 
	SetLocalOrigin(m_vecOrigin_);
	m_bOneWayActive = true;
	m_bRemotelyUpdated = false;
 
	BaseClass::Spawn();
}
 
void CAreaPortalOneWay::Activate()
{
	// Optimisation: share open/closed value for CAPOWs with the same GroupName.
	if (m_strGroupName != NULL_STRING)
		// m_AreaPortalsElement is a private member of CFuncAreaPortalBase. If this can't be changed, 
		// replace with g_AreaPortals.Find(this). DEFINITELY DO NOT use m_portalNumber!
		for( unsigned short i = m_AreaPortalsElement; i != g_AreaPortals.InvalidIndex(); i = g_AreaPortals.Next(i) )
		{
			CAreaPortalOneWay* pCur = dynamic_cast<CAreaPortalOneWay*>(g_AreaPortals[i]);
 
			if ( pCur && pCur != this && strcmp( STRING(m_strGroupName),STRING(pCur->m_strGroupName) ) == 0 )
			{
				m_pNextPortal = pCur;
				m_hNextPortal = pCur;
				break;
			}
		}
 
	BaseClass::Activate();
}
 
int CAreaPortalOneWay::Restore(IRestore &restore)
{
	if ( m_hNextPortal.IsValid() )
		m_pNextPortal = m_hNextPortal.Get();
 
	return BaseClass::Restore(restore);
}
 
// Disable the CAPOW (becomes a normal AP)
void CAreaPortalOneWay::InputDisableOneWay( inputdata_t &inputdata )
{
	m_bOneWayActive = false;
}
 
// Re-enable the CAPOW
void CAreaPortalOneWay::InputEnableOneWay( inputdata_t &inputdata )
{
	m_bOneWayActive = true;
}
 
// Toggle CAPOW
void CAreaPortalOneWay::InputToggleOneWay( inputdata_t &inputdata )
{
	m_bOneWayActive = !m_bOneWayActive;
}
 
// Flip the one way direction
void CAreaPortalOneWay::InputInvertOneWay( inputdata_t &inputdata )
{
	m_vecOpenVector.Negate();
}
 
// Recieve a shared state from another CAPOW, then pass it on to the next
void CAreaPortalOneWay::RemoteUpdate( bool IsOpen )
{
	m_bRemotelyUpdated = true;
	m_bRemoteCalcWasOpen = IsOpen;
	UpdateNextPortal(IsOpen);
}
 
// Inline func since this code is required three times
inline void CAreaPortalOneWay::UpdateNextPortal( bool IsOpen )
{
	if (m_pNextPortal)
		m_pNextPortal->RemoteUpdate(IsOpen);
}
 
#define VIEWER_PADDING 80 // Value copied from func_areaportalbase.cpp
 
bool CAreaPortalOneWay::UpdateVisibility( const Vector &vOrigin, float fovDistanceAdjustFactor, bool &bIsOpenOnClient )
{
	if (!m_bOneWayActive)
		return BaseClass::UpdateVisibility( vOrigin, fovDistanceAdjustFactor, bIsOpenOnClient );
 
	if( m_portalNumber == -1 || m_state == AREAPORTAL_CLOSED ) // m_state is a private member of CAreaPortal by default
	{
		bIsOpenOnClient = false;
		return false;
	}
 
	// Has another CAPOW on our plane already done a calculation?
	// Note that the CAPOW chain is traversed with new values in RemoteUpdate(), NOT here
	if (m_bRemotelyUpdated)
	{
		m_bRemotelyUpdated = false;
		return m_bRemoteCalcWasOpen ? BaseClass::UpdateVisibility( vOrigin, fovDistanceAdjustFactor, bIsOpenOnClient ) : false;
	}
 
	// ***********************
	// If we've got this far then we're the first CAPOW in the chain this frame
	// and need to calculate a value and pass it along said chain ourselves
	// ***********************
 
	float dist = VIEWER_PADDING; // Assume open for backfacing tests...
	VPlane plane;
	if( engine->GetAreaPortalPlane(vOrigin,m_portalNumber,&plane) )
		dist = plane.DistTo(vOrigin);	// ...but if we find a plane, use a genuine figure instead.
										// This is done because GetAreaPortalPlane only works for 
										// portals facing the current area.
 
	// We can use LocalOrigin here because APs never have parents.
	float dot = DotProduct(m_vecOpenVector,vOrigin - GetLocalOrigin());
 
	if( dot > 0 )
	{
		// We are on the open side of the portal. Pass the result on!
		UpdateNextPortal(true);
 
		// The following backfacing check is the inverse of CFuncAreaPortalBase's: 
		// it /closes/ the portal if the camera is /behind/ the plane. IsOpenOnClient
		// is left alone as per func_areaportalbase.h
		return dist < -VIEWER_PADDING ? false : true;
	}
	else // Closed side
	{
		// To avoid latency pop when crossing the portal's plane, it is only 
		// closed on the client if said client is outside the "padding zone".
		if ( !m_bAvoidPop || (m_bAvoidPop && dist > VIEWER_PADDING) )
			bIsOpenOnClient = false;
 
		// We are definitely closed on the server, however.
		UpdateNextPortal(false);
		return false;
	}
}