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;
}
DWORD CDamageSource::GetSovereignUNID (void) const
// GetSovereignUNID
//
// Returns the sovereign
{
CSovereign *pSovereign = GetSovereign();
if (pSovereign == NULL)
return 0;
return pSovereign->GetUNID();
}
bool CDamageSource::IsCausedByNonFriendOf (CSpaceObject *pObj) const
// IsCausedByNonFriendOf
//
// Returns TRUE if the damage is caused by an object that is
// not a friend of pObj and that can attack.
{
if (IsCausedByPlayer())
{
CSovereign *pSovereign = pObj->GetSovereign();
return (pSovereign ? !pSovereign->IsFriend(g_pUniverse->GetPlayerSovereign()) : false);
}
else
return (m_pSource && m_pSource->CanAttack() && !pObj->IsFriend(m_pSource));
}
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));
}
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;
}
void GenerateEncounterCount (CUniverse &Universe, CXMLElement *pCmdLine)
{
int i, j, k, l;
// Options
int iSystemSample = pCmdLine->GetAttributeIntegerBounded(CONSTLIT("count"), 1, -1, 1);
bool bLogo = !pCmdLine->GetAttributeBool(CONSTLIT("noLogo"));
bool bAll = pCmdLine->GetAttributeBool(CONSTLIT("all"));
// Additional columns
TArray<CString> Cols;
for (i = 0; i < pCmdLine->GetAttributeCount(); i++)
{
CString sAttrib = pCmdLine->GetAttributeName(i);
if (!IsMainCommandParam(sAttrib)
&& !strEquals(sAttrib, CONSTLIT("count"))
&& !strEquals(sAttrib, CONSTLIT("encountercount")))
{
CString sValue = pCmdLine->GetAttribute(i);
if (!strEquals(sValue, CONSTLIT("true")))
Cols.Insert(strPatternSubst(CONSTLIT("%s:%s"), sAttrib, sValue));
else
Cols.Insert(sAttrib);
}
}
// Generate systems for multiple games
TSortMap<CString, SNodeDesc> NodeTable;
for (i = 0; i < iSystemSample; i++)
{
if (bLogo)
printf("pass %d...\n", i+1);
// Initialize the game
CString sError;
if (Universe.InitGame(0, &sError) != NOERROR)
{
printf("%s\n", sError.GetASCIIZPointer());
return;
}
for (j = 0; j < Universe.GetTopologyNodeCount(); j++)
{
CTopologyNode *pNode = Universe.GetTopologyNode(j);
if (pNode->IsEndGame())
continue;
// Create the system
CSystem *pSystem;
if (Universe.CreateStarSystem(pNode, &pSystem) != NOERROR)
{
printf("ERROR: Unable to create star system.\n");
return;
}
// Create a sort string for this system
CString sSort = strPatternSubst(CONSTLIT("%02d-%s"), pSystem->GetLevel(), pNode->GetID());
// Get the table
bool bNew;
SNodeDesc *pResult = NodeTable.SetAt(sSort, &bNew);
if (bNew)
{
pResult->iLevel = pNode->GetLevel();
pResult->sNodeID = pNode->GetID();
}
// Accumulate data
AddSystemData(pSystem, bAll, pResult);
// Done with old system
Universe.DestroySystem(pSystem);
}
Universe.Reinit();
}
// Header
printf("Level\tNode\tSystemType\tCategory\tSovereign\tEncounter\tCount");
for (i = 0; i < Cols.GetCount(); i++)
printf("\t%s", Cols[i].GetASCIIZPointer());
printf("\n");
// Output all rows
for (i = 0; i < NodeTable.GetCount(); i++)
{
for (j = 0; j < NodeTable[i].Table.GetCount(); j++)
{
CCountTable &Encounters = NodeTable[i].Table[j];
for (k = 0; k < Encounters.GetCount(); k++)
{
int iCount = Encounters[k] / iSystemSample;
int iCountFrac = 1000 * (Encounters[k] % iSystemSample) / iSystemSample;
CStationType *pEncounterType = Universe.FindStationType(Encounters.GetKey(k));
if (pEncounterType == NULL)
continue;
CSovereign *pSovereign = pEncounterType->GetControllingSovereign();
CString sSovereign = (pSovereign ? pSovereign->GetTypeName() : CONSTLIT("(Unknown)"));
printf("%d\t%s\t0x%08x\t%s\t%s\t%s\t%d.%03d",
NodeTable[i].iLevel,
NodeTable[i].sNodeID.GetASCIIZPointer(),
NodeTable[i].Table.GetKey(j),
pEncounterType->GetDataField(CONSTLIT("category")).GetASCIIZPointer(),
sSovereign.GetASCIIZPointer(),
pEncounterType->GetName().GetASCIIZPointer(),
iCount,
iCountFrac);
for (l = 0; l < Cols.GetCount(); l++)
{
CString sValue = pEncounterType->GetDataField(Cols[l]);
printf("\t%s", sValue.GetASCIIZPointer());
}
printf("\n");
}
}
}
}
