void CPlayerGameStats::OnSystemEntered (CSystem *pSystem, int *retiLastVisit)
// OnSystemEntered
//
// Player just entered the system
{
CTopologyNode *pNode = pSystem->GetTopology();
if (pNode == NULL)
{
if (retiLastVisit)
*retiLastVisit = -1;
return;
}
SSystemStats *pStats = GetSystemStats(pNode->GetID());
pStats->dwLastEntered = g_pUniverse->GetTicks();
if (pStats->dwFirstEntered == INVALID_TIME)
{
pStats->dwFirstEntered = pStats->dwLastEntered;
if (retiLastVisit)
*retiLastVisit = -1;
}
else
{
if (retiLastVisit)
*retiLastVisit = (pStats->dwLastLeft != INVALID_TIME ? pStats->dwLastLeft : -1);
}
pStats->dwLastLeft = INVALID_TIME;
}
void CPlayerGameStats::OnKeyEvent (EEventTypes iType, CSpaceObject *pObj, DWORD dwCauseUNID)
// OnKeyEvent
//
// Adds a key event involving an object
{
ASSERT(pObj);
CSystem *pSystem = pObj->GetSystem();
if (pSystem == NULL)
return;
// Get the NodeID where the event happened
CTopologyNode *pNode = pSystem->GetTopology();
if (pNode == NULL)
return;
const CString &sNodeID = pNode->GetID();
// Get the object's type
CDesignType *pType = pObj->GetType();
if (pType == NULL)
return;
// Get the object's name
DWORD dwNameFlags;
CString sName = pObj->GetName(&dwNameFlags);
// If the object name is the same as the type name then we don't bother
// storing it in the event (to save memory)
if (strEquals(sName, pType->GetTypeName()))
{
sName = NULL_STR;
dwNameFlags = 0;
}
// Look for the list of events for this NodeID
TArray<SKeyEventStats> *pEventList = m_KeyEventStats.Set(sNodeID);
SKeyEventStats *pStats = pEventList->Insert();
pStats->iType = iType;
pStats->dwTime = g_pUniverse->GetTicks();
pStats->dwObjUNID = pObj->GetType()->GetUNID();
pStats->sObjName = sName;
pStats->dwObjNameFlags = dwNameFlags;
pStats->dwCauseUNID = dwCauseUNID;
}
void CPlayerGameStats::OnSystemLeft (CSystem *pSystem)
// OnSystemLeft
//
// Player just left the system
{
CTopologyNode *pNode = pSystem->GetTopology();
if (pNode == NULL)
return;
SSystemStats *pStats = GetSystemStats(pNode->GetID());
ASSERT(pStats->dwLastEntered != INVALID_TIME);
pStats->dwLastLeft = g_pUniverse->GetTicks();
pStats->dwTotalTime += pStats->dwLastLeft - pStats->dwLastEntered;
}
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");
}
}
}
}
void GenerateTopologyMap (CUniverse &Universe, CXMLElement *pCmdLine)
{
int i, j;
STopologyMapCtx Ctx;
// Initialize the output
COutputChart Output;
Output.SetStyleFont(STYLE_NAME, pCmdLine->GetAttribute(CONSTLIT("font")));
Output.SetStyleColor(STYLE_NAME, CG32bitPixel(0xFF, 0xFF, 0xFF));
Output.SetOutputFilespec(pCmdLine->GetAttribute(CONSTLIT("output")));
// Get the topology node
CTopologyNode *pFirstNode = Universe.GetFirstTopologyNode();
if (pFirstNode == NULL)
{
printf("ERROR: Unable to find topology node.\n");
return;
}
// Get the system map for the node
Ctx.pMap = pFirstNode->GetDisplayPos();
if (Ctx.pMap == NULL)
{
printf("ERROR: No system map for node %s.\n", pFirstNode->GetID().GetASCIIZPointer());
return;
}
// Create a background image
CG32bitImage *pImage = Ctx.pMap->CreateBackgroundImage();
// Create the output
Output.SetContentSize((pImage ? pImage->GetWidth() : 1024), (pImage ? pImage->GetHeight() : 1024));
CG32bitImage &Dest = Output.GetOutputImage();
// Blt
if (pImage)
Dest.Blt(0, 0, pImage->GetWidth(), pImage->GetHeight(), *pImage, 0, 0);
// Done with background image
delete pImage;
pImage = NULL;
// Compute the size of the map (in pixels)
Ctx.cxMap = Dest.GetWidth();
Ctx.cyMap = Dest.GetHeight();
Ctx.xCenter = Ctx.cxMap / 2;
Ctx.yCenter = Ctx.cyMap / 2;
// Loop over all nodes and clear marks on the ones that we need to draw
for (i = 0; i < Universe.GetTopologyNodeCount(); i++)
{
CTopologyNode *pNode = Universe.GetTopologyNode(i);
int xPos, yPos;
pNode->SetMarked(pNode->GetDisplayPos(&xPos, &yPos) != Ctx.pMap
|| pNode->IsEndGame());
}
// Paint the nodes
for (i = 0; i < Universe.GetTopologyNodeCount(); i++)
{
CTopologyNode *pNode = Universe.GetTopologyNode(i);
if (!pNode->IsMarked())
{
int xPos, yPos;
pNode->GetDisplayPos(&xPos, &yPos);
// Convert to view coordinates
int x = Ctx.xCenter + xPos;
int y = Ctx.yCenter - yPos;
// Draw gate connections
for (j = 0; j < pNode->GetStargateCount(); j++)
{
CTopologyNode *pDestNode = pNode->GetStargateDest(j);
if (pDestNode && !pDestNode->IsMarked())
{
int xPos, yPos;
pDestNode->GetDisplayPos(&xPos, &yPos);
int xDest = Ctx.xCenter + xPos;
int yDest = Ctx.yCenter - yPos;
Dest.DrawLine(x, y, xDest, yDest, STARGATE_LINE_WIDTH, STARGATE_LINE_COLOR);
}
}
// Draw star system
DrawNode(Ctx, Output, pNode, x, y);
pNode->SetMarked();
}
}
// Done
Output.Output();
}
void GenerateSnapshot (CUniverse &Universe, CXMLElement *pCmdLine)
{
ALERROR error;
int i;
// Get some parameters
int iInitialUpdateTime = 10;
int iUpdateTime = pCmdLine->GetAttributeInteger(CONSTLIT("wait"));
// Criteria
CString sNode = pCmdLine->GetAttribute(CONSTLIT("node"));
CString sCriteria = pCmdLine->GetAttribute(CONSTLIT("criteria"));
// Output
int cxWidth;
int cyHeight;
if (pCmdLine->FindAttributeInteger(CONSTLIT("size"), &cxWidth))
{
cyHeight = cxWidth;
}
else
{
cxWidth = 1024;
cyHeight = 1024;
}
// Paint flags
DWORD dwPaintFlags = 0;
if (pCmdLine->GetAttributeBool(CONSTLIT("noStars")))
dwPaintFlags |= CSystem::VWP_NO_STAR_FIELD;
// Output file
CString sFilespec = pCmdLine->GetAttribute(CONSTLIT("output"));
if (!sFilespec.IsBlank())
sFilespec = pathAddExtensionIfNecessary(sFilespec, CONSTLIT(".bmp"));
// Update context
SSystemUpdateCtx Ctx;
Ctx.bForceEventFiring = true;
Ctx.bForcePainted = true;
// Loop over all systems until we find what we're looking for
int iLoops = 20;
int iNodeIndex = 0;
CTopologyNode *pNode = Universe.GetTopologyNode(iNodeIndex);
while (true)
{
// Create the system
CSystem *pSystem;
if (error = Universe.CreateStarSystem(pNode, &pSystem))
{
printf("ERROR: Unable to create star system.\n");
return;
}
// If this is the node we want, then search
CSpaceObject *pTarget;
if (sNode.IsBlank() || strEquals(sNode, pNode->GetID()))
{
printf("Searching %s...\n", pNode->GetSystemName().GetASCIIZPointer());
// Set the POV
CSpaceObject *pPOV = pSystem->GetObject(0);
Universe.SetPOV(pPOV);
pSystem->SetPOVLRS(pPOV);
// Prepare system
Universe.UpdateExtended();
Universe.GarbageCollectLibraryBitmaps();
// Update for a while
for (i = 0; i < iInitialUpdateTime; i++)
Universe.Update(Ctx);
// Compose the criteria
CSpaceObject::Criteria Criteria;
CSpaceObject::ParseCriteria(pPOV, sCriteria, &Criteria);
// Get the list of all objects in the system that match the criteria
CSpaceObject::SCriteriaMatchCtx Ctx(Criteria);
TArray<CSpaceObject *> Results;
for (i = 0; i < pSystem->GetObjectCount(); i++)
{
CSpaceObject *pObj = pSystem->GetObject(i);
if (pObj && pObj->MatchesCriteria(Ctx, Criteria))
Results.Insert(pObj);
}
// Pick the appropriate object from the list
if (Results.GetCount() == 0)
pTarget = NULL;
else if (Criteria.bNearestOnly || Criteria.bFarthestOnly)
pTarget = Ctx.pBestObj;
else
pTarget = Results[mathRandom(0, Results.GetCount() - 1)];
}
else
pTarget = NULL;
// If we found the target, then output
if (pTarget)
{
// If we found the target, take a snapshot
printf("Found %s.\n", pTarget->GetNounPhrase(0).GetASCIIZPointer());
// Wait a bit
for (i = 0; i < iUpdateTime; i++)
{
if ((i % 100) == 99)
printf(".");
Universe.Update(Ctx);
}
if (iUpdateTime >= 99)
printf("\n");
// Paint
CG16bitImage Output;
Output.CreateBlank(cxWidth, cyHeight, false);
RECT rcViewport;
rcViewport.left = 0;
rcViewport.top = 0;
rcViewport.right = cxWidth;
rcViewport.bottom = cyHeight;
pSystem->PaintViewport(Output, rcViewport, pTarget, dwPaintFlags);
// Write to file
if (!sFilespec.IsBlank())
{
CFileWriteStream OutputFile(sFilespec);
if (OutputFile.Create() != NOERROR)
{
printf("ERROR: Unable to create '%s'\n", sFilespec.GetASCIIZPointer());
return;
}
Output.WriteToWindowsBMP(&OutputFile);
OutputFile.Close();
printf("%s\n", sFilespec.GetASCIIZPointer());
}
// Otherwise, clipboard
else
{
if (error = Output.CopyToClipboard())
{
printf("ERROR: Unable to copy image to clipboard.\n");
return;
}
printf("Image copied to clipboard.\n");
}
// Done
break;
}
// Done with old system
Universe.DestroySystem(pSystem);
// Loop to the next node
do
{
iNodeIndex = ((iNodeIndex + 1) % Universe.GetTopologyNodeCount());
pNode = Universe.GetTopologyNode(iNodeIndex);
}
while (pNode == NULL || pNode->IsEndGame());
// If we're back to the first node again, restart
if (iNodeIndex == 0)
{
if (--iLoops > 0)
{
Universe.Reinit();
iNodeIndex = 0;
pNode = Universe.GetTopologyNode(iNodeIndex);
}
else
{
printf("ERROR: Specified target could not be found.\n");
return;
}
}
}
}
void GenerateSnapshot (CUniverse &Universe, CXMLElement *pCmdLine)
{
ALERROR error;
int i;
// Get some parameters
int iInitialUpdateTime = pCmdLine->GetAttributeIntegerBounded(CONSTLIT("initialUpdate"), 0, -1, 10);
int iUpdateTime = pCmdLine->GetAttributeInteger(CONSTLIT("wait"));
bool bObjOnly = pCmdLine->GetAttributeBool(CONSTLIT("objOnly"));
// Criteria
CString sNode = pCmdLine->GetAttribute(CONSTLIT("node"));
CString sCriteria = pCmdLine->GetAttribute(CONSTLIT("criteria"));
// Number of snapshots
int iTotalCount = pCmdLine->GetAttributeIntegerBounded(CONSTLIT("count"), 1, -1, 1);
// Output
int cxWidth;
int cyHeight;
if (pCmdLine->FindAttributeInteger(CONSTLIT("size"), &cxWidth))
{
cyHeight = cxWidth;
}
else
{
cxWidth = 1024;
cyHeight = 1024;
}
// Paint flags
DWORD dwPaintFlags = 0;
if (pCmdLine->GetAttributeBool(CONSTLIT("noStars")))
dwPaintFlags |= CSystem::VWP_NO_STAR_FIELD;
// Output file
CString sFilespec = pCmdLine->GetAttribute(CONSTLIT("output"));
if (!sFilespec.IsBlank())
sFilespec = pathStripExtension(sFilespec);
// Output image
CG32bitImage Output;
Output.Create(cxWidth, cyHeight);
// Update context
SSystemUpdateCtx Ctx;
Ctx.bForceEventFiring = true;
Ctx.bForcePainted = true;
RECT rcViewport;
rcViewport.left = 0;
rcViewport.top = 0;
rcViewport.right = cxWidth;
rcViewport.bottom = cyHeight;
// Loop over all systems until we find what we're looking for
int iLoops = 20;
int iNodeIndex = 0;
int iSnapshotIndex = 0;
CTopologyNode *pNode = Universe.GetTopologyNode(iNodeIndex);
while (true)
{
// Create the system
CSystem *pSystem;
if (error = Universe.CreateStarSystem(pNode, &pSystem))
{
printf("ERROR: Unable to create star system.\n");
return;
}
// If this is the node we want, then search
CSpaceObject *pTarget;
if (sNode.IsBlank() || strEquals(sNode, pNode->GetID()))
{
printf("Searching %s...\n", pNode->GetSystemName().GetASCIIZPointer());
// Set the POV
CSpaceObject *pPOV = pSystem->GetObject(0);
Universe.SetPOV(pPOV);
pSystem->SetPOVLRS(pPOV);
// Prepare system
Universe.UpdateExtended();
Universe.GarbageCollectLibraryBitmaps();
// Update for a while
for (i = 0; i < iInitialUpdateTime; i++)
{
Universe.Update(Ctx);
Universe.PaintPOV(Output, rcViewport, 0);
}
// Compose the criteria
CSpaceObject::Criteria Criteria;
CSpaceObject::ParseCriteria(pPOV, sCriteria, &Criteria);
// Get the list of all objects in the system that match the criteria
CSpaceObject::SCriteriaMatchCtx Ctx(Criteria);
TArray<CSpaceObject *> Results;
for (i = 0; i < pSystem->GetObjectCount(); i++)
{
CSpaceObject *pObj = pSystem->GetObject(i);
if (pObj && pObj->MatchesCriteria(Ctx, Criteria))
Results.Insert(pObj);
}
// Pick the appropriate object from the list
if (Results.GetCount() == 0)
pTarget = NULL;
else if (Criteria.bNearestOnly || Criteria.bFarthestOnly)
pTarget = Ctx.pBestObj;
else
pTarget = Results[mathRandom(0, Results.GetCount() - 1)];
}
else
pTarget = NULL;
// If we found the target, then output
if (pTarget)
{
Universe.SetPOV(pTarget);
// Wait a bit
//
// NOTE: After we update, pTarget could be invalid (i.e., destroyed)
// so we can't use it again.
CString sTargetName = pTarget->GetNounPhrase(0);
for (i = 0; i < iUpdateTime; i++)
{
if ((i % 100) == 99)
printf(".");
Universe.Update(Ctx);
Universe.PaintPOV(Output, rcViewport, 0);
}
if (iUpdateTime >= 99)
printf("\n");
// Paint
if (bObjOnly)
{
SViewportPaintCtx Ctx;
Ctx.pObj = Universe.GetPOV();
Ctx.XForm = ViewportTransform(Universe.GetPOV()->GetPos(),
g_KlicksPerPixel,
cxWidth / 2,
cyHeight / 2);
Ctx.XFormRel = Ctx.XForm;
Ctx.fNoRecon = true;
Ctx.fNoDockedShips = true;
Ctx.fNoSelection = true;
Ctx.fNoStarfield = true;
CSpaceObject *pPOV = pSystem->GetObject(0);
CSpaceObject::Criteria Criteria;
CSpaceObject::ParseCriteria(pPOV, sCriteria, &Criteria);
// Paint all objects that match the criteria
CSpaceObject::SCriteriaMatchCtx CriteriaCtx(Criteria);
for (i = 0; i < pSystem->GetObjectCount(); i++)
{
CSpaceObject *pObj = pSystem->GetObject(i);
if (pObj && pObj->MatchesCriteria(CriteriaCtx, Criteria))
{
Ctx.pObj = pObj;
int xObj;
int yObj;
Ctx.XForm.Transform(pObj->GetPos(), &xObj, &yObj);
pObj->Paint(Output, xObj, yObj, Ctx);
}
}
}
else
{
Universe.PaintPOV(Output, rcViewport, 0);
}
// Write to file
if (!sFilespec.IsBlank())
{
CString sBmpFilespec;
if (iTotalCount > 100)
sBmpFilespec = pathAddExtensionIfNecessary(strPatternSubst(CONSTLIT("%s%03d"), sFilespec, iSnapshotIndex + 1), CONSTLIT(".bmp"));
else if (iTotalCount > 1)
sBmpFilespec = pathAddExtensionIfNecessary(strPatternSubst(CONSTLIT("%s%02d"), sFilespec, iSnapshotIndex + 1), CONSTLIT(".bmp"));
else
sBmpFilespec = pathAddExtensionIfNecessary(sFilespec, CONSTLIT(".bmp"));
CFileWriteStream OutputFile(sBmpFilespec);
if (OutputFile.Create() != NOERROR)
{
printf("ERROR: Unable to create '%s'\n", sBmpFilespec.GetASCIIZPointer());
return;
}
Output.WriteToWindowsBMP(&OutputFile);
OutputFile.Close();
printf("Found %s: Saved to %s\n", sTargetName.GetASCIIZPointer(), sBmpFilespec.GetASCIIZPointer());
}
// Otherwise, clipboard
else
{
if (error = Output.CopyToClipboard())
{
printf("ERROR: Unable to copy image to clipboard.\n");
return;
}
printf("Found %s: Copied to clipboard.\n", sTargetName.GetASCIIZPointer());
}
// Reset maximum loops
iLoops = 20;
// Done
iSnapshotIndex++;
if (iSnapshotIndex >= iTotalCount)
break;
}
// Done with old system
Universe.DestroySystem(pSystem);
// Loop to the next node
do
{
iNodeIndex = ((iNodeIndex + 1) % Universe.GetTopologyNodeCount());
pNode = Universe.GetTopologyNode(iNodeIndex);
}
while (pNode == NULL || pNode->IsEndGame());
// If we're back to the first node again, restart
if (iNodeIndex == 0)
{
if (--iLoops > 0)
{
// Reinitialize
Universe.Reinit();
CString sError;
if (Universe.InitGame(0, &sError) != NOERROR)
{
printf("ERROR: %s\n", sError.GetASCIIZPointer());
return;
}
iNodeIndex = 0;
pNode = Universe.GetTopologyNode(iNodeIndex);
}
else
{
printf("ERROR: Specified target could not be found.\n");
return;
}
}
}
}
void GenerateTopology (CUniverse &Universe, CXMLElement *pCmdLine)
{
int i, j, k;
int iCount = pCmdLine->GetAttributeIntegerBounded(COUNT_SWITCH, 1, -1, 1);
STopologyStats Stats;
for (k = 0; k < iCount; k++)
{
if (iCount > 1)
printf("sample %d", k+1);
TSortMap<CString, SNodeInfo> NodeData;
TSortMap<CString, int> AttribCount;
// Initialize the topology
CString sError;
Universe.GetFirstTopologyNode();
// Loop over all nodes
for (i = 0; i < Universe.GetTopologyNodeCount(); i++)
{
CTopologyNode *pNode = Universe.GetTopologyNode(i);
SNodeInfo *pNewNode = NodeData.Insert(pNode->GetID());
pNewNode->sID = pNode->GetID();
pNewNode->sName = pNode->GetSystemName();
pNewNode->dwSystemUNID = pNode->GetSystemDescUNID();
pNewNode->sAttribs = pNode->GetAttributes();
// Add the attributes in this node to the list of
// attributes for this try.
TArray<CString> Attribs;
ParseAttributes(pNewNode->sAttribs, &Attribs);
for (j = 0; j < Attribs.GetCount(); j++)
{
int *pCount = AttribCount.GetAt(Attribs[j]);
if (pCount == NULL)
{
pCount = AttribCount.Insert(Attribs[j]);
*pCount = 0;
}
*pCount = (*pCount) + 1;
}
}
// Compute topology stats
// Add the node count for this try
Stats.NodeCount.Insert(NodeData.GetCount());
// Loop over all attributes that we know about. If one doesn't
// exist in this try, then we set its min to 0
if (k > 0)
{
for (i = 0; i < Stats.Attribs.GetCount(); i++)
{
if (AttribCount.GetAt(Stats.Attribs.GetKey(i)) == NULL)
Stats.Attribs[i].SetMin(0);
}
}
// Loop over all attributes in this try and add them to the stats
SStat *pAttribStat;
for (i = 0; i < AttribCount.GetCount(); i++)
{
// If we have some attributes that no other try had, then
// that means that the minimum value is 0.
if (pAttribStat = Stats.Attribs.GetAt(AttribCount.GetKey(i)))
pAttribStat->Insert(AttribCount[i]);
else
{
pAttribStat = Stats.Attribs.Insert(AttribCount.GetKey(i));
pAttribStat->Insert(AttribCount[i]);
if (k > 0)
pAttribStat->SetMin(0);
}
}
// Output all the nodes
if (iCount == 1)
{
printf("Node\tSystemType\tName\tStargates\tAttributes\n");
for (i = 0; i < NodeData.GetCount(); i++)
{
SNodeInfo *pNode = &NodeData.GetValue(i);
printf("%s\t%08x\t%s\t%d\t%s\n",
pNode->sID.GetASCIIZPointer(),
pNode->dwSystemUNID,
pNode->sName.GetASCIIZPointer(),
pNode->Stargates.GetCount(),
pNode->sAttribs.GetASCIIZPointer());
}
}
else
{
Universe.Reinit();
printf("\n");
}
}
// Output stats
if (iCount > 0)
{
printf("\n");
printf("STATS\n\n");
Stats.NodeCount.Print(CONSTLIT("Nodes"), iCount, Stats.NodeCount.GetAverage(iCount));
printf("\n");
printf("ATTRIBS\n\n");
for (i = 0; i < Stats.Attribs.GetCount(); i++)
Stats.Attribs[i].Print(Stats.Attribs.GetKey(i), iCount, Stats.NodeCount.GetAverage(iCount));
printf("\n");
}
}
ALERROR CMission::Create (CMissionType *pType,
CSpaceObject *pOwner,
ICCItem *pCreateData,
CMission **retpMission,
CString *retsError)
// Create
//
// Creates a new mission object. We return ERR_NOTFOUND if the mission could
// not be created because conditions do not allow it.
{
CMission *pMission;
pMission = new CMission;
if (pMission == NULL)
{
*retsError = CONSTLIT("Out of memory");
return ERR_MEMORY;
}
pMission->m_pType = pType;
// Initialize
pMission->m_iStatus = statusOpen;
pMission->m_fIntroShown = false;
pMission->m_fDeclined = false;
pMission->m_fDebriefed = false;
pMission->m_pOwner = pOwner;
// NodeID
CTopologyNode *pNode = NULL;
CSystem *pSystem = NULL;
if ((pSystem = (pOwner ? pOwner->GetSystem() : g_pUniverse->GetCurrentSystem()))
&& (pNode = pSystem->GetTopology()))
pMission->m_sNodeID = pNode->GetID();
// Fire OnCreate
pMission->m_fInOnCreate = true;
CSpaceObject::SOnCreate OnCreate;
OnCreate.pData = pCreateData;
OnCreate.pOwnerObj = pOwner;
pMission->FireOnCreate(OnCreate);
pMission->m_fInOnCreate = false;
// If OnCreate destroyed the object then it means that the mission was not
// suitable. We return ERR_NOTFOUND
if (pMission->IsDestroyed())
{
delete pMission;
return ERR_NOTFOUND;
}
// If we haven't subscribed to the owner, do it now
if (pOwner && !pOwner->FindEventSubscriber(pMission))
pOwner->AddEventSubscriber(pMission);
// Done
if (retpMission)
*retpMission = pMission;
return NOERROR;
}
void GenerateSystemLabelCount (CUniverse &Universe, CXMLElement *pCmdLine)
{
ALERROR error;
int i, j;
CString sError;
enum STypes
{
typeSystemLabels,
typeNodeAttributes,
typeNodeDebug,
};
// Figure out what kind of output we want
STypes iType;
if (pCmdLine->GetAttributeBool(CONSTLIT("nodes")))
iType = typeNodeAttributes;
else if (pCmdLine->GetAttributeBool(CONSTLIT("nodeDebug")))
iType = typeNodeDebug;
else
iType = typeSystemLabels;
// Samples
int iSystemSample = pCmdLine->GetAttributeIntegerBounded(CONSTLIT("count"), 1, -1, 1);
// Options
bool bPermutations = pCmdLine->GetAttributeBool(CONSTLIT("permutations"));
// Generate systems for multiple games
CSystemCreateStats Stats;
Stats.AddPermuteAttrib(CONSTLIT("asteroids"));
Stats.AddPermuteAttrib(CONSTLIT("planetary"));
Stats.AddPermuteAttrib(CONSTLIT("void"));
Stats.AddPermuteAttrib(CONSTLIT("innerSystem"));
Stats.AddPermuteAttrib(CONSTLIT("lifeZone"));
Stats.AddPermuteAttrib(CONSTLIT("outerSystem"));
Stats.AddPermuteAttrib(CONSTLIT("envAir"));
Stats.AddPermuteAttrib(CONSTLIT("envEarth"));
Stats.AddPermuteAttrib(CONSTLIT("envFire"));
Stats.AddPermuteAttrib(CONSTLIT("envWater"));
bPermutations = true;
for (i = 0; i < iSystemSample; i++)
{
printf("pass %d...\n", i+1);
// Initialize the universe
if (error = Universe.InitGame(0, &sError))
{
printf("ERROR: %s", sError.GetASCIIZPointer());
return;
}
// Loop over all topology nodes
for (j = 0; j < Universe.GetTopologyNodeCount(); j++)
{
CTopologyNode *pNode = Universe.GetTopologyNode(j);
if (pNode->IsEndGame())
continue;
// Different stats depending on type
switch (iType)
{
case typeSystemLabels:
{
// Create the system and generate stats
CSystem *pSystem;
if (error = Universe.CreateStarSystem(pNode, &pSystem, NULL, &Stats))
{
printf("ERROR: Unable to create star system.\n");
return;
}
// Done
Universe.DestroySystem(pSystem);
break;
}
case typeNodeAttributes:
{
CString sAttribs = pNode->GetAttributes();
if (!sAttribs.IsBlank())
Stats.AddLabel(sAttribs);
else
Stats.AddLabel(CONSTLIT("[no attributes]"));
break;
}
case typeNodeDebug:
{
CString sAttribs = pNode->GetAttributes();
printf("%s: %s\n",
pNode->GetID().GetASCIIZPointer(),
pNode->GetAttributes().GetASCIIZPointer());
break;
}
}
}
}
// Titles
int iTotalLabels100 = Stats.GetTotalLabelCount() * 100 / iSystemSample;
int iTotalLabels = iTotalLabels100 / 100;
int iTotalLabelsDecimal = iTotalLabels100 % 100;
switch (iType)
{
case typeSystemLabels:
printf("LABEL STATISTICS\n\n");
printf("Average no. of labels per universe: %d.%02d\n\n", iTotalLabels, iTotalLabelsDecimal);
break;
case typeNodeAttributes:
printf("NODE ATTRIBUTES\n\n");
printf("Average no. of nodes per universe: %d.%02d\n\n", iTotalLabels, iTotalLabelsDecimal);
break;
}
// Nodes
if (iType != typeNodeDebug)
{
for (i = 0; i < Stats.GetLabelAttributesCount(); i++)
{
CString sAttribs;
int iCount;
Stats.GetLabelAttributes(i, &sAttribs, &iCount);
if (bPermutations || strFind(sAttribs, CONSTLIT(",")) == -1)
{
int iCount100 = iCount * 100 / iSystemSample;
int iPercent100 = iCount * 10000 / Stats.GetTotalLabelCount();
printf("%s: %d.%02d (%d.%02d%%)\n",
sAttribs.GetASCIIZPointer(),
iCount100 / 100,
iCount100 % 100,
iPercent100 / 100,
iPercent100 % 100);
}
}
}
}
void GenerateTopologyMap (CUniverse &Universe, CXMLElement *pCmdLine)
{
int i;
// Some parameters
int iScale = pCmdLine->GetAttributeIntegerBounded(CONSTLIT("scale"), 100, -1, -1);
// We need to create all systems so that the global object table is
// initialized.
for (i = 0; i < Universe.GetTopologyNodeCount(); i++)
{
CTopologyNode *pNode = Universe.GetTopologyNode(i);
// Do not try to create end game nodes
if (pNode->IsEndGame())
continue;
// Node is known
pNode->SetKnown();
// Create this system
CSystem *pNewSystem;
CString sError;
if (Universe.CreateStarSystem(pNode, &pNewSystem, &sError) != NOERROR)
{
printf("ERROR: creating system %s: %s\n", (LPSTR)pNode->GetSystemName(), (LPSTR)sError);
continue;
}
// Delete the system
Universe.FlushStarSystem(pNode);
}
// Initialize the output
COutputChart Output;
Output.SetStyleFont(STYLE_NAME, pCmdLine->GetAttribute(CONSTLIT("font")));
Output.SetStyleColor(STYLE_NAME, CG32bitPixel(0xFF, 0xFF, 0xFF));
Output.SetOutputFilespec(pCmdLine->GetAttribute(CONSTLIT("output")));
// Get the topology node
CTopologyNode *pFirstNode = Universe.GetFirstTopologyNode();
if (pFirstNode == NULL)
{
printf("ERROR: Unable to find topology node.\n");
return;
}
// Get the system map for the node
CSystemMap *pMap = pFirstNode->GetDisplayPos();
if (pMap == NULL)
{
printf("ERROR: No system map for node %s.\n", pFirstNode->GetID().GetASCIIZPointer());
return;
}
// If we didn't set a scale, use the map's initial scale
if (iScale == -1)
pMap->GetScale(&iScale);
// Initialize painting structures
CSystemMapThumbnails Thumbs;
Thumbs.Init(Universe.GetGlobalObjects());
CGalacticMapPainter Painter(Universe, pMap, Thumbs);
int cxMap = Painter.GetWidth() * iScale / 100;
int cyMap = Painter.GetHeight() * iScale / 100;
// Compute the size of the map
RECT rcView;
rcView.left = 0;
rcView.top = 0;
rcView.right = cxMap;
rcView.bottom = cyMap;
// Create the output
Output.SetContentSize(cxMap, cyMap);
CG32bitImage &Dest = Output.GetOutputImage();
// Paint
Painter.SetViewport(rcView);
Painter.SetScale(iScale);
Painter.SetPos(0, 0);
Painter.Paint(Dest);
// Done
Output.Output();
}