bool CNavigationPath::PathIsClear (CSystem *pSystem,
								   CSovereign *pSovereign,
								   const CVector &vFrom, 
								   const CVector &vTo, 
								   CSpaceObject **retpEnemy, 
								   CVector *retvAway)

//	PathIsClear
//
//	Returns TRUE if the path from vFrom to vTo is free from enemy stations.
//	If FALSE, retpEnemy is initialized with the enemy that is blocking the
//	path and retvAway is a unit vector away from the enemy that avoids it

	{
	int i;

	//	Loop over all objects in the system

	CSpaceObject *pNearestEnemy = NULL;
	Metric rNearestDist = MAX_SAFE_DIST;
	CVector vNearestAway;

	for (i = 0; i < pSystem->GetObjectCount(); i++)
		{
		CSpaceObject *pObj = pSystem->GetObject(i);
		CSovereign *pObjSovereign;

		if (pObj
				&& (pObj->GetScale() == scaleStructure 
					|| ((pObj->GetScale() == scaleShip) && (pObj->GetVel().Length2() < MIN_SPEED2)))
				&& (pObjSovereign = pObj->GetSovereign())
				&& (pObjSovereign->IsEnemy(pSovereign))
				&& pObj->CanAttack())
			{
			CVector vAway;
			Metric rDist = CalcDistanceToPath(pObj->GetPos(), vFrom, vTo, NULL, &vAway);
			if (rDist < rNearestDist)
				{
				rNearestDist = rDist;
				pNearestEnemy = pObj;
				vNearestAway = vAway;
				}
			}
		}

	//	If we found a threatening object, return it

	if (pNearestEnemy)
		{
		if (retpEnemy)
			*retpEnemy = pNearestEnemy;
		if (retvAway)
			*retvAway = vNearestAway;
		return false;
		}

	//	Otherwise, the path is OK

	return true;
	}
Beispiel #2
0
bool CDamageSource::IsCausedByEnemyOf (CSpaceObject *pObj) const

//	IsCausedByEnemyOf
//
//	Returns TRUE if the damage is caused by an object that is
//	an enemy of pObj.

	{
	if (IsCausedByPlayer())
		{
		CSovereign *pSovereign = pObj->GetSovereign();
		return (pSovereign ? pSovereign->IsEnemy(g_pUniverse->GetPlayerSovereign()) : false);
		}
	else
		return (m_pSource && m_pSource->CanAttack() && pObj->IsEnemy(m_pSource));
	}
Beispiel #3
0
CSovereign *GetAttackerSovereign (CUniverse &Universe, CStationType *pDefenderType)
	{
	int i;

	CSovereign *pDefenderSovereign = pDefenderType->GetSovereign();
	if (pDefenderSovereign)
		{
		for (i = 0; i < Universe.GetSovereignCount(); i++)
			{
			CSovereign *pSovereign = Universe.GetSovereign(i);
			if (pDefenderSovereign->IsEnemy(pSovereign))
				return pSovereign;
			}
		}

	return NULL;
	}