void AddSystemData (CSystem *pSystem, bool bAll, SNodeDesc *retResult)
{
int i;
// Loop over all objects
for (i = 0; i < pSystem->GetObjectCount(); i++)
{
CStationType *pType;
CSpaceObject *pObj = pSystem->GetObject(i);
if (pObj == NULL
|| pObj->IsDestroyed()
|| (pType = pObj->GetEncounterInfo()) == NULL)
continue;
// Skip if we're not interested in this encounter
if (!bAll && !pType->CanBeEncounteredRandomly())
continue;
// Get table
CCountTable *pTable = retResult->Table.SetAt(pSystem->GetType()->GetUNID());
// Add to count
bool bNew;
int *pCount = pTable->SetAt(pType->GetUNID(), &bNew);
if (bNew)
*pCount = 1;
else
*pCount += 1;
}
}
ALERROR CUniverse::InitLevelEncounterTables (void)
// InitLevelEncounterTables
//
// Initializes the m_LevelEncounterTables array based on the encounter
// tables of all the stations for each level.
{
m_LevelEncounterTables.RemoveAll();
for (int i = 1; i <= MAX_ITEM_LEVEL; i++)
{
CStructArray *pTable = new CStructArray(sizeof(SLevelEncounter), 8);
for (int j = 0; j < GetStationTypeCount(); j++)
{
CStationType *pType = GetStationType(j);
// Figure out the frequency of an encounter from this station based
// on the frequency of the station at this level and the frequency
// of encounters for this station.
int iEncounterFreq = pType->GetEncounterFrequency();
int iStationFreq = pType->GetFrequencyByLevel(i);
int iFreq = iEncounterFreq * iStationFreq / ftCommon;
// Add to the table
if (iFreq > 0)
{
pTable->ExpandArray(pTable->GetCount(), 1);
SLevelEncounter *pEntry = (SLevelEncounter *)pTable->GetStruct(pTable->GetCount()-1);
pEntry->iWeight = iFreq;
pEntry->pBaseSovereign = pType->GetSovereign();
pEntry->pTable = pType->GetEncountersTable();
}
}
m_LevelEncounterTables.AppendObject(pTable, NULL);
}
return NOERROR;
}
CStation::CStation( CStationType& stationType ) : CComponent( stationType ) /*CComponent( reinterpret_cast<CComponentType&>( stationType ) )*/
{
// Initialize the station's number (in the context of its station type)
number = stationType.getNoOfComponents() + 1;
// Initialize attributes
initialize();
// Add the station to simulation when created and connected to simulation
TfpAddStationToSimulation fpAddStationToSimulation = getStationType().getAddStationToSimulation();
if( fpAddStationToSimulation != NULL )
(*fpAddStationToSimulation)( this );
}
void OutputTradingStrategy (SItemTypeInfo &ItemInfo)
{
int i;
// Loop over all sellers and get the best price.
CStationType *pBestSeller = NULL;
int iBestSellerPrice;
for (i = 0; i < ItemInfo.SoldAt.GetCount(); i++)
{
SStationTradeInfo &Info = ItemInfo.SoldAt[i];
if (pBestSeller == NULL || Info.iMinPrice < iBestSellerPrice)
{
pBestSeller = Info.pStation;
iBestSellerPrice = Info.iMinPrice;
}
}
// Now get the best buyer's price
CStationType *pBestBuyer = NULL;
int iBestBuyerPrice;
for (i = 0; i < ItemInfo.BoughtBy.GetCount(); i++)
{
SStationTradeInfo &Info = ItemInfo.BoughtBy[i];
if (pBestBuyer == NULL || Info.iMaxPrice > iBestBuyerPrice)
{
pBestBuyer = Info.pStation;
iBestBuyerPrice = Info.iMaxPrice;
}
}
// Output
if (pBestSeller == NULL && pBestBuyer == NULL)
;
else if (pBestSeller == NULL)
printf("%s\t\t\t%s\t%d\t0.0%%\n",
ItemInfo.pItem->GetNounPhrase(nounActual).GetASCIIZPointer(),
pBestBuyer->GetNounPhrase().GetASCIIZPointer(),
iBestBuyerPrice);
else if (pBestBuyer == NULL)
printf("%s\t%s\t%d\t\t\t0.0%%\n",
ItemInfo.pItem->GetNounPhrase(nounActual).GetASCIIZPointer(),
pBestSeller->GetNounPhrase().GetASCIIZPointer(),
iBestSellerPrice);
else
printf("%s\t%s\t%d\t%s\t%d\t%2.2f%%\n",
ItemInfo.pItem->GetNounPhrase(nounActual).GetASCIIZPointer(),
pBestSeller->GetNounPhrase().GetASCIIZPointer(),
iBestSellerPrice,
pBestBuyer->GetNounPhrase().GetASCIIZPointer(),
iBestBuyerPrice,
100.0 * (double)(iBestBuyerPrice - iBestSellerPrice) / (double)iBestSellerPrice);
}
void GenerateEncounterTable (CUniverse &Universe, CXMLElement *pCmdLine)
{
ALERROR error;
int i, j;
// Get the criteria from the command line
SEncounterCriteria Criteria;
ParseEncounterCriteria(pCmdLine->GetAttribute(CRITERIA_ATTRIB), &Criteria);
bool bAll = pCmdLine->GetAttributeBool(ALL_ATTRIB);
// Generate a table of all matching encounters
CSymbolTable Table(FALSE, TRUE);
// Loop over all items for this level and add them to
// a sorted table.
for (i = 0; i < Universe.GetStationTypeCount(); i++)
{
CStationType *pType = Universe.GetStationType(i);
int iLevel = pType->GetLevel();
if (iLevel == 0 && !bAll)
continue;
// If we don't match the criteria, then continue
if (!MatchesEncounterCriteria(Criteria, pType->GetAttributes()))
continue;
// Get the category and name
CString sCategory = pType->GetDataField(FIELD_CATEGORY);
CString sName = pType->GetDataField(FIELD_NAME);
if (*sName.GetASCIIZPointer() == '(')
sName = strSubString(sName, 1, -1);
// Figure out the sort order
char szBuffer[1024];
wsprintf(szBuffer, "%02d%s%s",
pType->GetLevel(),
sCategory.GetASCIIZPointer(),
sName.GetASCIIZPointer());
Table.AddEntry(CString(szBuffer), (CObject *)pType);
}
// Generate a list of columns to display
CStringArray Cols;
Cols.AppendString(FIELD_LEVEL);
Cols.AppendString(FIELD_CATEGORY);
Cols.AppendString(FIELD_NAME);
if (pCmdLine->GetAttributeBool(FIELD_ARMOR_CLASS))
Cols.AppendString(FIELD_ARMOR_CLASS);
if (pCmdLine->GetAttributeBool(FIELD_HP))
Cols.AppendString(FIELD_HP);
if (pCmdLine->GetAttributeBool(FIELD_FIRE_RATE_ADJ))
Cols.AppendString(FIELD_FIRE_RATE_ADJ);
if (pCmdLine->GetAttributeBool(FIELD_TOTAL_COUNT))
Cols.AppendString(FIELD_TOTAL_COUNT);
if (pCmdLine->GetAttributeBool(FIELD_CAN_ATTACK))
Cols.AppendString(FIELD_CAN_ATTACK);
if (pCmdLine->GetAttributeBool(FIELD_EXPLOSION_TYPE))
Cols.AppendString(FIELD_EXPLOSION_TYPE);
// If we need to output total count, then load the table
CSymbolTable TotalCount(TRUE, TRUE);
if (pCmdLine->GetAttributeBool(FIELD_TOTAL_COUNT))
{
if (error = LoadTotalCount(TOTAL_COUNT_FILENAME, TotalCount))
return;
}
// If we've got any entries in the table, output now
if (Table.GetCount())
{
// Output the header
for (j = 0; j < Cols.GetCount(); j++)
{
if (j != 0)
printf("\t");
printf(Cols.GetStringValue(j).GetASCIIZPointer());
}
printf("\n");
// Output each row
for (i = 0; i < Table.GetCount(); i++)
{
CStationType *pType = (CStationType *)Table.GetValue(i);
for (j = 0; j < Cols.GetCount(); j++)
{
if (j != 0)
printf("\t");
CString sField = Cols.GetStringValue(j);
CString sValue = pType->GetDataField(sField);
if (strEquals(sField, FIELD_FIRE_RATE_ADJ))
printf("%.2f", strToInt(sValue, 0, NULL) / 1000.0);
else if (strEquals(sField, FIELD_TOTAL_COUNT))
{
double rCount = 0.0;
CString sKey = strFromInt(pType->GetUNID(), FALSE);
EntryInfo *pEntry;
if (TotalCount.Lookup(sKey, (CObject **)&pEntry) == NOERROR)
rCount = pEntry->rTotalCount;
printf("%.2f", rCount);
}
else
printf(sValue.GetASCIIZPointer());
}
printf("\n");
}
printf("\n");
}
else
printf("No entries match criteria.\n");
}
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 RunEncounterSim (CUniverse &Universe, CXMLElement *pCmdLine)
{
int iRuns = pCmdLine->GetAttributeIntegerBounded(COUNT_ATTRIB, 1, -1, DEFAULT_RUN_COUNT);
int iTimeOut = DEFAULT_TIME_OUT;
// Get the station criteria
CString sCriteria = strPatternSubst(CONSTLIT("%s t"), pCmdLine->GetAttribute(DEFENDERS_ATTRIB));
CDesignTypeCriteria DefenderCriteria;
if (CDesignTypeCriteria::ParseCriteria(sCriteria, &DefenderCriteria) != NOERROR)
{
printf("ERROR: Unable to parse defenders criteria.\n");
return;
}
bool bAll = pCmdLine->GetAttributeBool(CONSTLIT("all"));
// Get the criteria from the command line. Always append 's' because we
// want ship classes.
sCriteria = strPatternSubst(CONSTLIT("%s s"), pCmdLine->GetAttribute(ATTACKERS_ATTRIB));
CDesignTypeCriteria AttackerCriteria;
if (CDesignTypeCriteria::ParseCriteria(sCriteria, &AttackerCriteria) != NOERROR)
{
printf("ERROR: Unable to parse attackers criteria.\n");
return;
}
// Create a viewer, if desired
CSimViewer Viewer;
if (pCmdLine->GetAttributeBool(VIEWER_ATTRIB))
Viewer.Create();
// Print headers
printf("Encounter\tLevel");
int iAttacker;
for (iAttacker = 0; iAttacker < Universe.GetShipClassCount(); iAttacker++)
{
CShipClass *pAttackerClass = Universe.GetShipClass(iAttacker);
if (!pAttackerClass->MatchesCriteria(AttackerCriteria))
continue;
printf("\t%s", pAttackerClass->GetName().GetASCIIZPointer());
}
printf("\n");
// Loop over all defenders
int iDefender;
for (iDefender = 0; iDefender < Universe.GetStationTypeCount(); iDefender++)
{
CStationType *pDefenderType = Universe.GetStationType(iDefender);
if (!bAll && pDefenderType->GetLevel() == 0)
continue;
if (!pDefenderType->MatchesCriteria(DefenderCriteria))
continue;
// Compute an enemy of the station
CSovereign *pAttackerSovereign = GetAttackerSovereign(Universe, pDefenderType);
if (pAttackerSovereign == NULL)
{
printf("ERROR: Unable to find enemy sovereign of encounter: %s [%x].\n", pDefenderType->GetNounPhrase().GetASCIIZPointer(), pDefenderType->GetUNID());
return;
}
printf("%s [%x]\t%d", pDefenderType->GetNounPhrase().GetASCIIZPointer(), pDefenderType->GetUNID(), pDefenderType->GetLevel());
// Loop over all attackers
for (iAttacker = 0; iAttacker < Universe.GetShipClassCount(); iAttacker++)
{
CShipClass *pAttackerClass = Universe.GetShipClass(iAttacker);
if (!pAttackerClass->MatchesCriteria(AttackerCriteria))
continue;
// Do several runs so we can get some statistical data
int iAttackerSurvived = 0;
int iRun;
for (iRun = 0; iRun < iRuns; iRun++)
{
EResults iResult = RunEncounter(Universe, Viewer, pDefenderType, pAttackerClass, pAttackerSovereign);
if (iResult == resultError)
return;
// Did the attacker survive?
if (iResult != resultAttackerDestroyed)
iAttackerSurvived++;
}
// Output results for this attacker
int iSurvivability = 100 * iAttackerSurvived / iRuns;
printf("\t%d%%", iSurvivability);
}
printf("\n");
}
Viewer.Destroy();
}
void GenerateSimTables (CUniverse &Universe, CXMLElement *pCmdLine)
{
ALERROR error;
int i, j;
int iSystemSample = pCmdLine->GetAttributeInteger(CONSTLIT("count"));
if (iSystemSample == 0)
iSystemSample = DEFAULT_SYSTEM_SAMPLE;
// Generate systems for multiple games
CSymbolTable AllSystems(TRUE, TRUE);
for (i = 0; i < iSystemSample; i++)
{
printf("sample %d...\n", i+1);
CTopologyNode *pNode = Universe.GetFirstTopologyNode();
while (true)
{
// Create the system
CSystem *pSystem;
if (error = Universe.CreateStarSystem(pNode, &pSystem))
{
printf("ERROR: Unable to create star system.\n");
return;
}
// Find this system in the table.
SystemInfo *pSystemEntry;
if (error = AllSystems.Lookup(pNode->GetSystemName(), (CObject **)&pSystemEntry))
{
pSystemEntry = new SystemInfo;
pSystemEntry->sName = pNode->GetSystemName();
pSystemEntry->iLevel = pNode->GetLevel();
pSystemEntry->dwSystemType = pNode->GetSystemDescUNID();
pSystemEntry->iCount = 1;
AllSystems.AddEntry(pSystemEntry->sName, pSystemEntry);
}
else
pSystemEntry->iCount++;
// Add the encounters to the appropriate tables
for (j = 0; j < pSystem->GetObjectCount(); j++)
{
CSpaceObject *pObj = pSystem->GetObject(j);
if (pObj)
{
// Add this encounter to the table
CStationType *pType;
if (pType = pObj->GetEncounterInfo())
{
CString sKey = strFromInt(pType->GetUNID(), false);
// See if we have this type in the table
StationInfo *pEntry;
if (error = pSystemEntry->Stations.Lookup(sKey, (CObject **)&pEntry))
{
pEntry = new StationInfo;
pEntry->pType = pType;
pEntry->iSystemCount = 0;
pEntry->iTotalCount = 1;
pSystemEntry->Stations.AddEntry(sKey, pEntry);
}
else
pEntry->iTotalCount++;
}
// Enumerate the items in this object
CItemListManipulator ItemList(pObj->GetItemList());
ItemList.ResetCursor();
while (ItemList.MoveCursorForward())
{
const CItem &Item(ItemList.GetItemAtCursor());
if (!Item.IsInstalled() && !Item.IsDamaged())
{
CString sKey = strFromInt(Item.GetType()->GetUNID(), false);
// Find the item type in the table
ItemInfo *pEntry;
if (error = pSystemEntry->Items.Lookup(sKey, (CObject **)&pEntry))
{
pEntry = new ItemInfo;
pEntry->pType = Item.GetType();
pEntry->iTotalCount = Item.GetCount();
pSystemEntry->Items.AddEntry(sKey, pEntry);
}
else
pEntry->iTotalCount += Item.GetCount();
}
}
}
}
// Get the next node
CString sEntryPoint;
pNode = pSystem->GetStargateDestination(CONSTLIT("Outbound"), &sEntryPoint);
if (pNode == NULL || pNode->IsEndGame())
break;
// Done with old system
Universe.DestroySystem(pSystem);
}
Universe.Reinit();
}
// Output
if (error = OutputItemTable(AllSystems, iSystemSample))
return;
if (error = OutputEncounterTable(AllSystems, iSystemSample))
return;
// Create a table with the sum of all items for the game
printf("Total count statistic computed.\n");
}
void GenerateEncounterTable (CUniverse &Universe, CXMLElement *pCmdLine)
{
ALERROR error;
int i, j;
// Get the criteria from the command line. Always append 't' because we
// want station types.
CString sCriteria = strPatternSubst(CONSTLIT("%s t"), pCmdLine->GetAttribute(CRITERIA_ATTRIB));
// Parse it
CDesignTypeCriteria Criteria;
if (CDesignTypeCriteria::ParseCriteria(sCriteria, &Criteria) != NOERROR)
{
printf("ERROR: Unable to parse criteria.\n");
return;
}
bool bAll = pCmdLine->GetAttributeBool(ALL_ATTRIB);
// Generate a table of all matching encounters
CSymbolTable Table(FALSE, TRUE);
// Loop over all items for this level and add them to
// a sorted table.
for (i = 0; i < Universe.GetStationTypeCount(); i++)
{
CStationType *pType = Universe.GetStationType(i);
int iLevel = pType->GetLevel();
if (iLevel == 0 && !bAll)
continue;
// If we don't match the criteria, then continue
if (!pType->MatchesCriteria(Criteria))
continue;
// Get the category and name
CString sCategory = pType->GetDataField(FIELD_CATEGORY);
CString sName = pType->GetDataField(FIELD_NAME);
if (*sName.GetASCIIZPointer() == '(')
sName = strSubString(sName, 1, -1);
// Figure out the sort order
char szBuffer[1024];
wsprintf(szBuffer, "%02d%s%s",
pType->GetLevel(),
sCategory.GetASCIIZPointer(),
sName.GetASCIIZPointer());
Table.AddEntry(CString(szBuffer), (CObject *)pType);
}
// Generate a list of columns to display
TArray<CString> Cols;
Cols.Insert(FIELD_LEVEL);
Cols.Insert(FIELD_CATEGORY);
Cols.Insert(FIELD_NAME);
for (i = 0; i < pCmdLine->GetAttributeCount(); i++)
{
CString sAttrib = pCmdLine->GetAttributeName(i);
if (!strEquals(sAttrib, CONSTLIT("all"))
&& !strEquals(sAttrib, CONSTLIT("criteria"))
&& !strEquals(sAttrib, CONSTLIT("encountertable"))
&& !strEquals(sAttrib, CONSTLIT("nologo")))
{
CString sValue = pCmdLine->GetAttribute(i);
if (!strEquals(sValue, CONSTLIT("true")))
Cols.Insert(strPatternSubst(CONSTLIT("%s:%s"), sAttrib, sValue));
else
Cols.Insert(sAttrib);
}
}
#if 0
if (pCmdLine->GetAttributeBool(FIELD_ARMOR_CLASS))
Cols.Insert(FIELD_ARMOR_CLASS);
if (pCmdLine->GetAttributeBool(FIELD_HP))
Cols.Insert(FIELD_HP);
if (pCmdLine->GetAttributeBool(FIELD_FIRE_RATE_ADJ))
Cols.Insert(FIELD_FIRE_RATE_ADJ);
if (pCmdLine->GetAttributeBool(FIELD_TOTAL_COUNT))
Cols.Insert(FIELD_TOTAL_COUNT);
if (pCmdLine->GetAttributeBool(FIELD_CAN_ATTACK))
Cols.Insert(FIELD_CAN_ATTACK);
if (pCmdLine->GetAttributeBool(FIELD_EXPLOSION_TYPE))
Cols.Insert(FIELD_EXPLOSION_TYPE);
#endif
// If we need to output total count, then load the table
CSymbolTable TotalCount(TRUE, TRUE);
if (pCmdLine->GetAttributeBool(FIELD_TOTAL_COUNT))
{
if (error = LoadTotalCount(TOTAL_COUNT_FILENAME, TotalCount))
return;
}
// If we've got any entries in the table, output now
if (Table.GetCount())
{
// Output the header
for (j = 0; j < Cols.GetCount(); j++)
{
if (j != 0)
printf("\t");
printf(Cols[j].GetASCIIZPointer());
}
printf("\n");
// Output each row
for (i = 0; i < Table.GetCount(); i++)
{
CStationType *pType = (CStationType *)Table.GetValue(i);
for (j = 0; j < Cols.GetCount(); j++)
{
if (j != 0)
printf("\t");
const CString &sField = Cols[j];
CString sValue = pType->GetDataField(sField);
if (strEquals(sField, FIELD_FIRE_RATE_ADJ))
printf("%.2f", strToInt(sValue, 0, NULL) / 1000.0);
else if (strEquals(sField, FIELD_TOTAL_COUNT))
{
double rCount = 0.0;
CString sKey = strFromInt(pType->GetUNID(), false);
EntryInfo *pEntry;
if (TotalCount.Lookup(sKey, (CObject **)&pEntry) == NOERROR)
rCount = pEntry->rTotalCount;
printf("%.2f", rCount);
}
else
printf(sValue.GetASCIIZPointer());
}
printf("\n");
}
printf("\n");
}
else
printf("No entries match criteria.\n");
}
void CPlayerGameStats::GenerateGameStats (CGameStats &Stats, CSpaceObject *pPlayerShip, bool bGameOver) const
// GenerateGameStats
//
// Generates a stats for everything we track
{
int j;
CShip *pShip = (pPlayerShip ? pPlayerShip->AsShip() : NULL);
if (pShip == NULL)
return;
CPlayerShipController *pPlayer = (CPlayerShipController *)pShip->GetController();
if (pPlayer == NULL)
return;
CSovereign *pPlayerSovereign = g_pUniverse->FindSovereign(g_PlayerSovereignUNID);
if (pPlayerSovereign == NULL)
return;
// Base stats
Stats.Insert(CONSTLIT("Genome"), strCapitalize(GetGenomeName(pPlayer->GetPlayerGenome())));
Stats.Insert(CONSTLIT("Score"), strFormatInteger(CalcEndGameScore(), -1, FORMAT_THOUSAND_SEPARATOR | FORMAT_UNSIGNED));
Stats.Insert(CONSTLIT("Ship class"), pShip->GetNounPhrase(0));
CTimeSpan Time = GetPlayTime();
if (!Time.IsBlank())
Stats.Insert(CONSTLIT("Time played"), Time.Format(NULL_STR));
#ifdef REAL_TIME
Time = GetGameTime();
if (!Time.IsBlank())
Stats.Insert(CONSTLIT("Time elapsed in game"), Time.Format(NULL_STR));
#endif
// Some combat stats
CString sDestroyed = GetStat(ENEMY_SHIPS_DESTROYED_STAT);
if (!sDestroyed.IsBlank())
Stats.Insert(CONSTLIT("Enemy ships destroyed"), sDestroyed, CONSTLIT("combat"));
sDestroyed = GetStat(FRIENDLY_SHIPS_DESTROYED_STAT);
if (!sDestroyed.IsBlank())
Stats.Insert(CONSTLIT("Friendly ships destroyed"), sDestroyed, CONSTLIT("combat"));
sDestroyed = GetStat(ENEMY_STATIONS_DESTROYED_STAT);
if (!sDestroyed.IsBlank())
Stats.Insert(CONSTLIT("Enemy stations destroyed"), sDestroyed, CONSTLIT("combat"));
sDestroyed = GetStat(FRIENDLY_STATIONS_DESTROYED_STAT);
if (!sDestroyed.IsBlank())
Stats.Insert(CONSTLIT("Friendly stations destroyed"), sDestroyed, CONSTLIT("combat"));
// Add stat for every station destroyed
CStatCounterArray CounterArray;
CMapIterator i;
m_StationStats.Reset(i);
while (m_StationStats.HasMore(i))
{
SStationTypeStats *pStats;
DWORD dwUNID = m_StationStats.GetNext(i, &pStats);
CStationType *pType = g_pUniverse->FindStationType(dwUNID);
if (pType == NULL)
continue;
CString sName = pType->GetNounPhrase(0);
CString sSort = strPatternSubst(CONSTLIT("%03d%s"), 100 - pType->GetLevel(), sName);
if (pType->GetSovereign()->IsEnemy(pPlayerSovereign))
CounterArray.Insert(sName, pStats->iDestroyed, CONSTLIT("Enemy stations destroyed"), sSort);
else
CounterArray.Insert(sName, pStats->iDestroyed, CONSTLIT("Friendly stations destroyed"), sSort);
}
CounterArray.GenerateGameStats(Stats);
// Add stat for every ship class destroyed
CounterArray.DeleteAll();
m_ShipStats.Reset(i);
while (m_ShipStats.HasMore(i))
{
SShipClassStats *pStats;
DWORD dwUNID = m_ShipStats.GetNext(i, &pStats);
CShipClass *pClass = g_pUniverse->FindShipClass(dwUNID);
if (pClass == NULL)
continue;
CString sName = pClass->GetNounPhrase(0);
CString sSort = strPatternSubst(CONSTLIT("%09d%s"), 100000000 - pClass->GetScore(), sName);
if (pStats->iEnemyDestroyed > 0)
CounterArray.Insert(sName, pStats->iEnemyDestroyed, CONSTLIT("Enemy ships destroyed"), sSort);
if (pStats->iFriendDestroyed > 0)
CounterArray.Insert(sName, pStats->iFriendDestroyed, CONSTLIT("Friendly ships destroyed"), sSort);
}
CounterArray.GenerateGameStats(Stats);
// Add stat for every weapon fired
m_ItemStats.Reset(i);
while (m_ItemStats.HasMore(i))
{
SItemTypeStats *pStats;
DWORD dwUNID = m_ItemStats.GetNext(i, &pStats);
CItemType *pItemType = g_pUniverse->FindItemType(dwUNID);
if (pItemType == NULL)
continue;
CString sName = pItemType->GetNounPhrase(nounShort);
CString sSort = strPatternSubst(CONSTLIT("%03d%s"), 100 - pItemType->GetLevel(), sName);
// Installed items
if (pStats->dwFirstInstalled != INVALID_TIME)
Stats.Insert(sName, NULL_STR, CONSTLIT("Items installed"), sSort);
if (pStats->iCountFired > 0)
Stats.Insert(sName,
strFormatInteger(pStats->iCountFired, -1, FORMAT_THOUSAND_SEPARATOR | FORMAT_UNSIGNED),
CONSTLIT("Weapons fired"),
sSort);
}
// Stats for player equipment (but only if the game is done)
if (bGameOver)
{
TSortMap<CString, CItem> InstalledItems;
// First we generate a sorted list of installed items
// (We do this in case there are multiple of the same device/armor so that
// we can coalesce them together into a single line).
CItemListManipulator ItemList(pShip->GetItemList());
ItemList.ResetCursor();
while (ItemList.MoveCursorForward())
{
const CItem &Item(ItemList.GetItemAtCursor());
if (Item.IsInstalled())
{
CString sEnhancement = Item.GetEnhancedDesc(pShip);
CString sItemName = Item.GetNounPhrase(nounActual | nounCountOnly | nounShort);
CString sLine = (sEnhancement.IsBlank() ? sItemName : strPatternSubst(CONSTLIT("%s [%s]"), sItemName, sEnhancement));
bool bInserted;
CItem *pEntry = InstalledItems.SetAt(sLine, &bInserted);
if (bInserted)
{
*pEntry = Item;
pEntry->SetCount(1);
}
else
pEntry->SetCount(pEntry->GetCount() + 1);
}
}
// Now add all the installed items to the stats
for (j = 0; j < InstalledItems.GetCount(); j++)
{
// Redo the line now that we know the proper count
CString sEnhancement = InstalledItems[j].GetEnhancedDesc(pShip);
CString sItemName = InstalledItems[j].GetNounPhrase(nounActual | nounCountOnly);
CString sLine = (sEnhancement.IsBlank() ? sItemName : strPatternSubst(CONSTLIT("%s [%s]"), sItemName, sEnhancement));
// Compute the sort order
int iOrder;
switch (InstalledItems[j].GetType()->GetCategory())
{
case itemcatWeapon:
iOrder = 0;
break;
case itemcatLauncher:
iOrder = 1;
break;
case itemcatShields:
iOrder = 2;
break;
case itemcatArmor:
iOrder = 3;
break;
case itemcatReactor:
iOrder = 4;
break;
case itemcatDrive:
iOrder = 5;
break;
default:
iOrder = 6;
break;
}
CString sSort = strPatternSubst(CONSTLIT("%d%03d%s"), iOrder, 100 - InstalledItems[j].GetType()->GetLevel(), sLine);
Stats.Insert(sLine, NULL_STR, CONSTLIT("Final equipment"), sSort);
}
// Add the remaining items
ItemList.ResetCursor();
while (ItemList.MoveCursorForward())
{
const CItem &Item(ItemList.GetItemAtCursor());
if (!Item.IsInstalled())
{
CString sEnhancement = Item.GetEnhancedDesc(pShip);
CString sItemName = Item.GetNounPhrase(nounActual | nounCountOnly);
CString sLine = (sEnhancement.IsBlank() ? sItemName : strPatternSubst(CONSTLIT("%s [%s]"), sItemName, sEnhancement));
CString sSort = strPatternSubst(CONSTLIT("%03d%s"), 100 - Item.GetType()->GetLevel(), sLine);
Stats.Insert(sLine, NULL_STR, CONSTLIT("Final items"), sSort);
}
}
}
}
void GenerateImageChart (CUniverse &Universe, CXMLElement *pCmdLine)
{
int i;
enum OrderTypes
{
orderSmallest = 1,
orderLargest = 2,
orderName = 3,
orderLevel = 4,
orderSovereign = 5,
orderManufacturer = 6,
};
// Item criteria
bool bHasItemCriteria;
CString sCriteria;
CItemCriteria ItemCriteria;
if (bHasItemCriteria = pCmdLine->FindAttribute(CONSTLIT("itemCriteria"), &sCriteria))
CItem::ParseCriteria(sCriteria, &ItemCriteria);
else
CItem::InitCriteriaAll(&ItemCriteria);
// Get the criteria from the command line.
CDesignTypeCriteria Criteria;
if (pCmdLine->FindAttribute(CONSTLIT("criteria"), &sCriteria))
{
if (CDesignTypeCriteria::ParseCriteria(sCriteria, &Criteria) != NOERROR)
{
printf("ERROR: Unable to parse criteria.\n");
return;
}
}
else if (bHasItemCriteria)
{
if (CDesignTypeCriteria::ParseCriteria(CONSTLIT("i"), &Criteria) != NOERROR)
{
printf("ERROR: Unable to parse criteria.\n");
return;
}
}
else
{
printf("ERROR: Expected criteria.\n");
return;
}
bool bAll = pCmdLine->GetAttributeBool(CONSTLIT("all"));
// Options
bool bTextBoxesOnly = pCmdLine->GetAttributeBool(CONSTLIT("textBoxesOnly"));
bool bFieldUNID = pCmdLine->GetAttributeBool(CONSTLIT("unid"));
// Figure out what order we want
CString sOrder = pCmdLine->GetAttribute(CONSTLIT("sort"));
int iOrder;
if (strEquals(sOrder, CONSTLIT("smallest")))
iOrder = orderSmallest;
else if (strEquals(sOrder, CONSTLIT("largest")))
iOrder = orderLargest;
else if (strEquals(sOrder, CONSTLIT("level")))
iOrder = orderLevel;
else if (strEquals(sOrder, CONSTLIT("sovereign")))
iOrder = orderSovereign;
else if (strEquals(sOrder, CONSTLIT("manufacturer")))
iOrder = orderManufacturer;
else
iOrder = orderName;
bool b3DGrid = pCmdLine->GetAttributeBool(CONSTLIT("3DGrid"));
bool bDockingPorts = pCmdLine->GetAttributeBool(CONSTLIT("portPos"));
bool bDevicePos = pCmdLine->GetAttributeBool(CONSTLIT("devicePos"));
// Image size
int cxDesiredWidth;
if (pCmdLine->FindAttributeInteger(CONSTLIT("width"), &cxDesiredWidth))
cxDesiredWidth = Max(512, cxDesiredWidth);
else
cxDesiredWidth = 1280;
// Spacing
int cxSpacing = pCmdLine->GetAttributeInteger(CONSTLIT("xSpacing"));
int cxExtraMargin = pCmdLine->GetAttributeInteger(CONSTLIT("xMargin"));
int cxImageMargin = 2 * pCmdLine->GetAttributeInteger(CONSTLIT("xImageMargin"));
// Font for text
CString sTypeface;
int iSize;
bool bBold;
bool bItalic;
if (!CG16bitFont::ParseFontDesc(pCmdLine->GetAttribute(CONSTLIT("font")),
&sTypeface,
&iSize,
&bBold,
&bItalic))
{
sTypeface = CONSTLIT("Arial");
iSize = 10;
bBold = false;
bItalic = false;
}
CG16bitFont NameFont;
NameFont.Create(sTypeface, -PointsToPixels(iSize), bBold, bItalic);
CG32bitPixel rgbNameColor = CG32bitPixel(255, 255, 255);
// Rotation
int iRotation = pCmdLine->GetAttributeInteger(CONSTLIT("rotation"));
// Output file
CString sFilespec = pCmdLine->GetAttribute(CONSTLIT("output"));
if (!sFilespec.IsBlank())
sFilespec = pathAddExtensionIfNecessary(sFilespec, CONSTLIT(".bmp"));
// Generate a sorted table of types
TSortMap<CString, SEntryDesc> Table;
for (i = 0; i < Universe.GetDesignTypeCount(); i++)
{
CDesignType *pType = Universe.GetDesignType(i);
SEntryDesc NewEntry;
// Make sure we match the criteria
if (!pType->MatchesCriteria(Criteria))
continue;
// Figure stuff stuff out based on the specific design type
switch (pType->GetType())
{
case designItemType:
{
CItemType *pItemType = CItemType::AsType(pType);
CItem Item(pItemType, 1);
// Skip if not in item criteria
if (!Item.MatchesCriteria(ItemCriteria))
continue;
// Skip virtual classes
if (pItemType->IsVirtual())
continue;
// Initialize the entry
NewEntry.pType = pType;
NewEntry.sName = pItemType->GetNounPhrase(0);
NewEntry.pImage = &pItemType->GetImage();
NewEntry.iSize = RectWidth(NewEntry.pImage->GetImageRect());
break;
}
case designShipClass:
{
CShipClass *pClass = CShipClass::AsType(pType);
// Skip non-generic classess
if (!bAll && !pClass->HasLiteralAttribute(CONSTLIT("genericClass")))
continue;
// Initialize the entry
NewEntry.pType = pType;
NewEntry.sName = pClass->GetNounPhrase(0);
NewEntry.iSize = RectWidth(pClass->GetImage().GetImageRect());
NewEntry.pImage = &pClass->GetImage();
NewEntry.iRotation = pClass->Angle2Direction(iRotation);
NewEntry.sSovereignName = (pClass->GetDefaultSovereign() ? pClass->GetDefaultSovereign()->GetTypeNounPhrase() : NULL_STR);
break;
}
case designStationType:
{
CStationType *pStationType = CStationType::AsType(pType);
// Skip generic classes
if (!bAll && !pStationType->HasLiteralAttribute(CONSTLIT("generic")))
continue;
NewEntry.pType = pType;
NewEntry.sName = pStationType->GetNounPhrase(0);
NewEntry.iSize = pStationType->GetSize();
NewEntry.sSovereignName = (pStationType->GetSovereign() ? pStationType->GetSovereign()->GetTypeNounPhrase() : NULL_STR);
InitStationTypeImage(NewEntry, pStationType);
break;
}
default:
// Don't know how to handle this type
continue;
break;
}
// Adjust name
if (bFieldUNID)
NewEntry.sName = strPatternSubst(CONSTLIT("%s (%x)"), NewEntry.sName, NewEntry.pType->GetUNID());
// Compute the sort key
char szBuffer[1024];
switch (iOrder)
{
case orderLargest:
wsprintf(szBuffer, "%09d%s%x",
1000000 - NewEntry.iSize,
NewEntry.sName.GetASCIIZPointer(),
pType->GetUNID());
break;
case orderLevel:
wsprintf(szBuffer, "%09d%s%x",
pType->GetLevel(),
NewEntry.sName.GetASCIIZPointer(),
pType->GetUNID());
break;
case orderSmallest:
wsprintf(szBuffer, "%09d%s%x",
NewEntry.iSize,
NewEntry.sName.GetASCIIZPointer(),
pType->GetUNID());
break;
case orderSovereign:
wsprintf(szBuffer, "%s|%s|%x", NewEntry.sSovereignName.GetASCIIZPointer(), NewEntry.sName.GetASCIIZPointer(), pType->GetUNID());
NewEntry.sCategorize = NewEntry.sSovereignName;
break;
case orderManufacturer:
{
CString sManufacturer = NewEntry.pType->GetPropertyString(CONSTLIT("manufacturer"));
wsprintf(szBuffer, "%s|%s|%x", sManufacturer.GetASCIIZPointer(), NewEntry.sName.GetASCIIZPointer(), pType->GetUNID());
NewEntry.sCategorize = sManufacturer;
break;
}
default:
wsprintf(szBuffer, "%s%x", NewEntry.sName.GetASCIIZPointer(), pType->GetUNID());
break;
}
// Add to list
Table.Insert(CString(szBuffer), NewEntry);
}
// Allocate an arranger that tracks where to paint each world.
CImageArranger Arranger;
// Settings for the overall arrangement
CImageArranger::SArrangeDesc Desc;
Desc.cxDesiredWidth = Max(512, cxDesiredWidth - (2 * (cxSpacing + cxExtraMargin)));
Desc.cxSpacing = cxSpacing;
Desc.cxExtraMargin = cxExtraMargin;
Desc.pHeader = &NameFont;
// Generate a table of cells for the arranger
TArray<CCompositeImageSelector> Selectors;
Selectors.InsertEmpty(Table.GetCount());
CString sLastCategory;
TArray<CImageArranger::SCellDesc> Cells;
for (i = 0; i < Table.GetCount(); i++)
{
SEntryDesc &Entry = Table[i];
CImageArranger::SCellDesc *pNewCell = Cells.Insert();
pNewCell->cxWidth = (Entry.pImage ? RectWidth(Entry.pImage->GetImageRect()) : 0) + cxImageMargin;
pNewCell->cyHeight = (Entry.pImage ? RectHeight(Entry.pImage->GetImageRect()) : 0) + cxImageMargin;
pNewCell->sText = Entry.sName;
if (!strEquals(sLastCategory, Entry.sCategorize))
{
sLastCategory = Entry.sCategorize;
pNewCell->bStartNewRow = true;
}
}
// Arrange
Arranger.ArrangeByRow(Desc, Cells);
// Create a large image
CG32bitImage Output;
int cxWidth = Max(cxDesiredWidth, Arranger.GetWidth());
int cyHeight = Arranger.GetHeight();
Output.Create(cxWidth, cyHeight);
printf("Creating %dx%d image.\n", cxWidth, cyHeight);
// Paint the images
for (i = 0; i < Table.GetCount(); i++)
{
SEntryDesc &Entry = Table[i];
int x = Arranger.GetX(i);
int y = Arranger.GetY(i);
// Paint
if (x != -1)
{
int xCenter = x + (Arranger.GetWidth(i) / 2);
int yCenter = y + (Arranger.GetHeight(i) / 2);
int xOffset;
int yOffset;
Entry.pImage->GetImageOffset(0, Entry.iRotation, &xOffset, &yOffset);
int cxImage = RectWidth(Entry.pImage->GetImageRect());
int cyImage = RectHeight(Entry.pImage->GetImageRect());
// Paint image
if (!bTextBoxesOnly && Entry.pImage)
{
Entry.pImage->PaintImageUL(Output,
x + (Arranger.GetWidth(i) - cxImage) / 2,
y + (Arranger.GetHeight(i) - cyImage) / 2,
0,
Entry.iRotation);
}
// Paint type specific stuff
switch (Entry.pType->GetType())
{
case designStationType:
{
CStationType *pStationType = CStationType::AsType(Entry.pType);
int xStationCenter = xCenter - xOffset;
int yStationCenter = yCenter - yOffset;
if (bDockingPorts)
pStationType->PaintDockPortPositions(Output, xStationCenter, yStationCenter);
if (bDevicePos)
pStationType->PaintDevicePositions(Output, xStationCenter, yStationCenter);
// If we have docking or device positions, mark the center of the station
if (bDockingPorts || bDevicePos)
{
const int LINE_HALF_LENGTH = 24;
const CG32bitPixel RGB_CENTER_CROSS(255, 255, 0);
Output.DrawLine(xStationCenter - LINE_HALF_LENGTH, yStationCenter, xStationCenter + LINE_HALF_LENGTH, yStationCenter, 1, RGB_CENTER_CROSS);
Output.DrawLine(xStationCenter, yStationCenter - LINE_HALF_LENGTH, xStationCenter, yStationCenter + LINE_HALF_LENGTH, 1, RGB_CENTER_CROSS);
}
break;
}
}
// Paint the 3D grid, if necessary
if (b3DGrid)
{
int iScale = Entry.pImage->GetImageViewportSize();
Metric rMaxRadius = g_KlicksPerPixel * cxImage * 0.5;
const Metric rGridSize = LIGHT_SECOND;
Metric rRadius;
for (rRadius = rGridSize; rRadius <= rMaxRadius; rRadius += rGridSize)
{
int iRadius = (int)((rRadius / g_KlicksPerPixel) + 0.5);
const int iGridAngle = 8;
int iPrevAngle = 0;
int iAngle;
for (iAngle = iGridAngle; iAngle <= 360; iAngle += iGridAngle)
{
int xFrom, yFrom;
C3DConversion::CalcCoord(iScale, iPrevAngle, iRadius, 0, &xFrom, &yFrom);
int xTo, yTo;
C3DConversion::CalcCoord(iScale, iAngle, iRadius, 0, &xTo, &yTo);
Output.DrawLine(xFrom + xCenter, yFrom + yCenter, xTo + xCenter, yTo + yCenter, 1, CG32bitPixel(255, 255, 0));
iPrevAngle = iAngle;
}
}
}
// Paint name
int xText = Arranger.GetTextX(i);
int yText = Arranger.GetTextY(i);
if (xText != -1)
{
if (bTextBoxesOnly)
Output.Fill(xText, yText, Arranger.GetTextWidth(i), Arranger.GetTextHeight(i), 0xffff);
if (!bTextBoxesOnly)
{
Output.FillColumn(xCenter,
y + Arranger.GetHeight(i),
yText - (y + Arranger.GetHeight(i)),
rgbNameColor);
NameFont.DrawText(Output,
xText,
yText,
rgbNameColor,
Entry.sName);
}
}
}
}
// Write to file or clipboard
OutputImage(Output, sFilespec);
}
void InitStationTypeImage (SEntryDesc &Entry, CStationType *pStationType)
{
struct SSatImageDesc
{
const CObjectImageArray *pImage;
CCompositeImageSelector Selector;
int xOffset;
int yOffset;
};
int i;
SSelectorInitCtx InitCtx;
pStationType->SetImageSelector(InitCtx, &Entry.Selector);
const CObjectImageArray *pMainImage = &pStationType->GetImage(Entry.Selector, CCompositeImageModifiers());
// If we have no satellites, then we can just return the single station
// image.
CXMLElement *pSatellites = pStationType->GetSatellitesDesc();
if (pSatellites == NULL)
{
Entry.pImage = pMainImage;
return;
}
// Figure out the extents of the image
RECT rcMainImage = pMainImage->GetImageRect();
RECT rcBounds;
rcBounds.left = -(RectWidth(rcMainImage) / 2);
rcBounds.top = -(RectHeight(rcMainImage) / 2);
rcBounds.right = rcBounds.left + RectWidth(rcMainImage);
rcBounds.bottom = rcBounds.top + RectHeight(rcMainImage);
// Loop over all satellites and get metrics
TArray<SSatImageDesc> SatImages;
for (i = 0; i < pSatellites->GetContentElementCount(); i++)
{
CXMLElement *pSatDesc = pSatellites->GetContentElement(i);
if (!pSatDesc->FindAttribute(SEGMENT_ATTRIB)
|| !strEquals(STATION_TAG, pSatDesc->GetTag()))
continue;
// Get the type of the satellite
CStationType *pSatType = g_pUniverse->FindStationType(pSatDesc->GetAttributeInteger(TYPE_ATTRIB));
if (pSatType == NULL)
continue;
// Prepare the image for the satellite
SSatImageDesc *pSatImage = SatImages.Insert();
pSatType->SetImageSelector(InitCtx, &pSatImage->Selector);
// If we have an image variant, then set it
int iVariant;
if (pSatDesc->FindAttributeInteger(IMAGE_VARIANT_ATTRIB, &iVariant))
{
IImageEntry *pRoot = pSatType->GetImage().GetRoot();
DWORD dwID = (pRoot ? pRoot->GetID() : DEFAULT_SELECTOR_ID);
pSatImage->Selector.DeleteAll();
pSatImage->Selector.AddVariant(dwID, iVariant);
}
pSatImage->pImage = &pSatType->GetImage(pSatImage->Selector, CCompositeImageModifiers());
// Now get the offset
pSatImage->xOffset = pSatDesc->GetAttributeInteger(X_OFFSET_ATTRIB);
pSatImage->yOffset = pSatDesc->GetAttributeInteger(Y_OFFSET_ATTRIB);
// Compute the satellite rect
RECT rcSatImage = pSatImage->pImage->GetImageRect();
RECT rcSatBounds;
rcSatBounds.left = pSatImage->xOffset - (RectWidth(rcSatImage) / 2);
rcSatBounds.top = -pSatImage->yOffset - (RectHeight(rcSatImage) / 2);
rcSatBounds.right = rcSatBounds.left + RectWidth(rcSatImage);
rcSatBounds.bottom = rcSatBounds.top + RectHeight(rcSatImage);
// Increase the size of the bounds
rcBounds.left = Min(rcBounds.left, rcSatBounds.left);
rcBounds.right = Max(rcBounds.right, rcSatBounds.right);
rcBounds.top = Min(rcBounds.top, rcSatBounds.top);
rcBounds.bottom = Max(rcBounds.bottom, rcSatBounds.bottom);
}
// If no segments, then we just return the basic image
if (SatImages.GetCount() == 0)
{
Entry.pImage = pMainImage;
return;
}
// Create an image that will hold the composite
CG32bitImage *pCompositeImage = new CG32bitImage;
pCompositeImage->Create(RectWidth(rcBounds), RectHeight(rcBounds), CG32bitImage::alpha8, CG32bitPixel::Null());
int xCenter = -rcBounds.left;
int yCenter = -rcBounds.top;
// Paint the main image
pMainImage->PaintImage(*pCompositeImage, xCenter, yCenter, 0, Entry.iRotation, true);
// Paint all the satellites
for (i = 0; i < SatImages.GetCount(); i++)
SatImages[i].pImage->PaintImage(*pCompositeImage, xCenter + SatImages[i].xOffset, yCenter - SatImages[i].yOffset, 0, 0, true);
// Now create the proper image array
RECT rcResult;
rcResult.left = 0;
rcResult.top = 0;
rcResult.right = RectWidth(rcBounds);
rcResult.bottom = RectHeight(rcBounds);
int xOffset = (RectWidth(rcBounds) / 2) - xCenter;
int yOffset = (RectHeight(rcBounds) / 2) - yCenter;
Entry.pCompositeImageArray = new CObjectImageArray;
Entry.pCompositeImageArray->Init(pCompositeImage, rcResult, 0, 0, true, xOffset, yOffset);
// Done
Entry.pImage = Entry.pCompositeImageArray;
}
void GenerateStationFrequencyTable (CUniverse &Universe, CXMLElement *pCmdLine)
{
int i, j;
printf("STATION FREQUENCY TABLE\n\n");
// Figure out which columns to show
TArray<CString> Cols;
Cols.Insert(CONSTLIT("Level"));
Cols.Insert(CONSTLIT("Freq"));
Cols.Insert(CONSTLIT("Name"));
Cols.Insert(CONSTLIT("Type"));
Cols.Insert(CONSTLIT("Environment"));
// Print the header
for (i = 0; i < Cols.GetCount(); i++)
{
if (i != 0)
printf("\t");
printf("%s", (LPSTR)Cols[i]);
}
printf("\n");
// For all levels, 1-25
int iLevel;
for (iLevel = 1; iLevel <= MAX_ITEM_LEVEL; iLevel++)
{
CSymbolTable Sort(FALSE, TRUE);
// Find all stations for this level and add them to
// a sorting table
for (i = 0; i < Universe.GetStationTypeCount(); i++)
{
CStationType *pType = Universe.GetStationType(i);
if (pType->GetFrequencyByLevel(iLevel) > 0)
{
char szBuffer[256];
wsprintf(szBuffer, "%02d %s",
ftCommon - pType->GetFrequencyByLevel(iLevel),
pType->GetName().GetASCIIZPointer());
Sort.AddEntry(CString(szBuffer), (CObject *)pType);
}
}
// Print out the stations for this level
if (Sort.GetCount() > 0)
{
for (i = 0; i < Sort.GetCount(); i++)
{
CStationType *pType = (CStationType *)Sort.GetValue(i);
for (j = 0; j < Cols.GetCount(); j++)
{
if (j != 0)
printf("\t");
if (strEquals(Cols[j], CONSTLIT("Level")))
printf("%d", iLevel);
else if (strEquals(Cols[j], CONSTLIT("Freq")))
printf((LPSTR)FrequencyChar(pType->GetFrequencyByLevel(iLevel)));
else if (strEquals(Cols[j], CONSTLIT("Name")))
printf((LPSTR)pType->GetName());
else if (strEquals(Cols[j], CONSTLIT("Type")))
{
if (pType->HasAttribute(CONSTLIT("enemy")))
printf("Enemy");
else if (pType->HasAttribute(CONSTLIT("debris")))
printf("Debris");
else
printf("Friend");
}
else if (strEquals(Cols[j], CONSTLIT("Environment")))
{
bool bElements = false;
if (pType->HasAttribute(CONSTLIT("envAir")))
{
if (bElements)
printf(", ");
printf("envAir");
bElements = true;
}
if (pType->HasAttribute(CONSTLIT("envEarth")))
{
if (bElements)
printf(", ");
printf("envEarth");
bElements = true;
}
if (pType->HasAttribute(CONSTLIT("envFire")))
{
if (bElements)
printf(", ");
printf("envFire");
bElements = true;
}
if (pType->HasAttribute(CONSTLIT("envWater")))
{
if (bElements)
printf(", ");
printf("envWater");
bElements = true;
}
if (!bElements)
printf("None");
}
}
printf("\n");
}
}
}
}
void GenerateEncounterTable (CUniverse &Universe, CXMLElement *pCmdLine, CIDTable &EntityTable)
{
ALERROR error;
int i, j;
// Get the criteria from the command line. Always append 't' because we
// want station types.
CString sCriteria = strPatternSubst(CONSTLIT("%s t"), pCmdLine->GetAttribute(CRITERIA_ATTRIB));
// Parse it
CDesignTypeCriteria Criteria;
if (CDesignTypeCriteria::ParseCriteria(sCriteria, &Criteria) != NOERROR)
{
printf("ERROR: Unable to parse criteria.\n");
return;
}
bool bAll = pCmdLine->GetAttributeBool(ALL_ATTRIB);
bool bOnlyNotRandom = pCmdLine->GetAttributeBool(ONLY_NOT_RANDOM_ATTRIB);
// Generate a table of all matching encounters
CSymbolTable Table(FALSE, TRUE);
// Loop over all items for this level and add them to
// a sorted table.
for (i = 0; i < Universe.GetStationTypeCount(); i++)
{
CStationType *pType = Universe.GetStationType(i);
int iLevel = pType->GetLevel();
// If we're selecting all types, then do it
if (bAll)
;
// If we only want non-random types, then skip any random encounters.
else if (bOnlyNotRandom)
{
if (pType->CanBeEncounteredRandomly())
continue;
}
// Otherwise we skip anything except random encounters.
else
{
if (!pType->CanBeEncounteredRandomly())
continue;
}
// If we don't match the criteria, then continue
if (!pType->MatchesCriteria(Criteria))
continue;
// Get the category and name
CString sCategory = pType->GetDataField(FIELD_CATEGORY);
CString sName = pType->GetDataField(FIELD_NAME);
if (*sName.GetASCIIZPointer() == '(')
sName = strSubString(sName, 1, -1);
// Figure out the sort order
char szBuffer[1024];
wsprintf(szBuffer, "%02d%s%s%08x",
iLevel,
sCategory.GetASCIIZPointer(),
sName.GetASCIIZPointer(),
pType->GetUNID());
Table.AddEntry(CString(szBuffer), (CObject *)pType);
}
// Generate a list of columns to display
TArray<CString> Cols;
Cols.Insert(FIELD_LEVEL);
Cols.Insert(FIELD_CATEGORY);
Cols.Insert(FIELD_NAME);
for (i = 0; i < pCmdLine->GetAttributeCount(); i++)
{
CString sAttrib = pCmdLine->GetAttributeName(i);
if (!IsMainCommandParam(sAttrib)
&& !strEquals(sAttrib, ONLY_NOT_RANDOM_ATTRIB)
&& !strEquals(sAttrib, CONSTLIT("encountertable")))
{
CString sValue = pCmdLine->GetAttribute(i);
if (!strEquals(sValue, CONSTLIT("true")))
Cols.Insert(strPatternSubst(CONSTLIT("%s:%s"), sAttrib, sValue));
else
Cols.Insert(sAttrib);
}
}
// If we need to output total count, then load the table
CDesignTypeStats TotalCount;
if (pCmdLine->GetAttributeBool(FIELD_TOTAL_COUNT)
|| pCmdLine->GetAttributeBool(FIELD_COUNT_DISTRIBUTION))
{
if (error = LoadDesignTypeStats(&TotalCount))
return;
}
// If we've got any entries in the table, output now
if (Table.GetCount())
{
// Output the header
for (j = 0; j < Cols.GetCount(); j++)
{
if (j != 0)
printf("\t");
printf(Cols[j].GetASCIIZPointer());
}
printf("\n");
// Output each row
for (i = 0; i < Table.GetCount(); i++)
{
CStationType *pType = (CStationType *)Table.GetValue(i);
for (j = 0; j < Cols.GetCount(); j++)
{
if (j != 0)
printf("\t");
const CString &sField = Cols[j];
// Get the value
CString sValue;
if (strEquals(sField, FIELD_ENTITY))
{
CString *pValue;
if (EntityTable.Lookup(pType->GetUNID(), (CObject **)&pValue) == NOERROR)
sValue = *pValue;
else
sValue = CONSTLIT("?");
}
else
sValue = pType->GetDataField(sField);
// Format and output
if (strEquals(sField, FIELD_FIRE_RATE_ADJ))
printf("%.2f", strToInt(sValue, 0, NULL) / 1000.0);
else if (strEquals(sField, FIELD_TOTAL_COUNT))
{
SDesignTypeInfo *pInfo = TotalCount.GetAt(pType->GetUNID());
double rCount = (pInfo ? pInfo->rPerGameMeanCount : 0.0);
printf("%.2f", rCount);
}
else if (strEquals(sField, FIELD_COUNT_DISTRIBUTION))
{
SDesignTypeInfo *pInfo = TotalCount.GetAt(pType->GetUNID());
printf("%s", (pInfo ? pInfo->sDistribution : NULL_STR).GetASCIIZPointer());
}
else
printf(sValue.GetASCIIZPointer());
}
printf("\n");
}
printf("\n");
}
else
printf("No entries match criteria.\n");
}
CString CPlayerGameStats::GetStat (const CString &sStat) const
// GetStat
//
// Returns the given stat
{
if (strEquals(sStat, BEST_ENEMY_SHIPS_DESTROYED_STATS))
{
DWORD dwUNID;
int iCount = GetBestEnemyShipsDestroyed(&dwUNID);
if (iCount == 0)
return NULL_STR;
return strPatternSubst(CONSTLIT("'(%d %d)"), dwUNID, iCount);
}
else if (strEquals(sStat, ENEMY_SHIPS_DESTROYED_STAT))
{
CMapIterator i;
int iCount = 0;
m_ShipStats.Reset(i);
while (m_ShipStats.HasMore(i))
{
SShipClassStats *pStats;
DWORD dwUNID = m_ShipStats.GetNext(i, &pStats);
iCount += pStats->iEnemyDestroyed;
}
if (iCount + m_iExtraEnemyShipsDestroyed == 0)
return NULL_STR;
return ::strFromInt(iCount + m_iExtraEnemyShipsDestroyed);
}
else if (strEquals(sStat, ENEMY_STATIONS_DESTROYED_STAT))
{
CSovereign *pPlayerSovereign = g_pUniverse->FindSovereign(g_PlayerSovereignUNID);
if (pPlayerSovereign == NULL)
return NULL_STR;
CMapIterator i;
int iCount = 0;
m_StationStats.Reset(i);
while (m_StationStats.HasMore(i))
{
SStationTypeStats *pStats;
DWORD dwUNID = m_StationStats.GetNext(i, &pStats);
CStationType *pType = g_pUniverse->FindStationType(dwUNID);
if (pType == NULL)
continue;
if (pType->GetSovereign()->IsEnemy(pPlayerSovereign))
iCount += pStats->iDestroyed;
}
if (iCount == 0)
return NULL_STR;
return ::strFromInt(iCount);
}
else if (strEquals(sStat, FRIENDLY_SHIPS_DESTROYED_STAT))
{
CMapIterator i;
int iCount = 0;
m_ShipStats.Reset(i);
while (m_ShipStats.HasMore(i))
{
SShipClassStats *pStats;
DWORD dwUNID = m_ShipStats.GetNext(i, &pStats);
iCount += pStats->iFriendDestroyed;
}
if (iCount == 0)
return NULL_STR;
return ::strFromInt(iCount);
}
else if (strEquals(sStat, FRIENDLY_STATIONS_DESTROYED_STAT))
{
CSovereign *pPlayerSovereign = g_pUniverse->FindSovereign(g_PlayerSovereignUNID);
if (pPlayerSovereign == NULL)
return NULL_STR;
CMapIterator i;
int iCount = 0;
m_StationStats.Reset(i);
while (m_StationStats.HasMore(i))
{
SStationTypeStats *pStats;
DWORD dwUNID = m_StationStats.GetNext(i, &pStats);
CStationType *pType = g_pUniverse->FindStationType(dwUNID);
if (pType == NULL)
continue;
if (!pType->GetSovereign()->IsEnemy(pPlayerSovereign))
iCount += pStats->iDestroyed;
}
if (iCount == 0)
return NULL_STR;
return ::strFromInt(iCount);
}
else if (strEquals(sStat, RESURRECT_COUNT_STAT))
return ::strFromInt(m_iResurrectCount);
else if (strEquals(sStat, SCORE_STAT))
return ::strFromInt(m_iScore);
else if (strEquals(sStat, SYSTEM_DATA_STAT))
{
CMemoryWriteStream Output;
if (Output.Create() != NOERROR)
return NIL_VALUE;
Output.Write("'(", 2);
CMapIterator i;
m_SystemStats.Reset(i);
while (m_SystemStats.HasMore(i))
{
SSystemStats *pStats;
const CString &sNodeID = m_SystemStats.GetNext(i, &pStats);
Output.Write("(", 1);
Output.Write(sNodeID.GetASCIIZPointer(), sNodeID.GetLength());
Output.Write(" ", 1);
WriteTimeValue(Output, pStats->dwFirstEntered);
Output.Write(" ", 1);
WriteTimeValue(Output, pStats->dwLastEntered);
Output.Write(" ", 1);
WriteTimeValue(Output, pStats->dwLastLeft);
Output.Write(" ", 1);
WriteTimeValue(Output, pStats->dwTotalTime);
Output.Write(") ", 2);
}
Output.Write(")", 1);
return CString(Output.GetPointer(), Output.GetLength());
}
else if (strEquals(sStat, SYSTEMS_VISITED_STAT))
{
CMapIterator i;
int iCount = 0;
m_SystemStats.Reset(i);
while (m_SystemStats.HasMore(i))
{
SSystemStats *pStats;
const CString &sNodeID = m_SystemStats.GetNext(i, &pStats);
if (pStats->dwLastEntered != INVALID_TIME)
iCount++;
}
return ::strFromInt(iCount + m_iExtraSystemsVisited);
}
else
return NULL_STR;
}
void CSystemCreateStats::AddFillLocationsTable (CSystem *pSystem, const TProbabilityTable<int> &LocationTable, const CString &sStationCriteria)
// AddFillLocationsTable
//
// Adds stats about <FillLocations>
{
int i, j;
if (LocationTable.GetCount() == 0)
return;
SFillLocationsTable *pEntry = m_FillLocationsTables.Insert();
pEntry->iLevel = pSystem->GetLevel();
pEntry->sSystemName = pSystem->GetName();
pEntry->pSystemType = pSystem->GetType();
pEntry->sStationCriteria = sStationCriteria;
// Parse station criteria if we've got it.
// NOTE: For now we only do enemies.
CString sEnemyStationCriteria = strPatternSubst(CONSTLIT("%s,%s"), sStationCriteria, CONSTLIT("*enemy"));
CAttributeCriteria StationCriteria;
StationCriteria.Parse(sEnemyStationCriteria, 0);
// Start by generating a base probability for all station encounters
// relative to the system.
TProbabilityTable<CStationType *> BaseProb;
for (i = 0; i < g_pUniverse->GetStationTypeCount(); i++)
{
CStationType *pType = g_pUniverse->GetStationType(i);
int iBaseChance = StationCriteria.AdjStationWeight(pType, ((1000 / ftCommon) * pType->GetFrequencyForSystem(pSystem)));
if (iBaseChance > 0)
{
CAttributeCriteria LocationCriteria;
LocationCriteria.Parse(pType->GetLocationCriteria(), 0);
// Average out our chance of ending up at one of the given locations.
int iTotal = 0;
for (j = 0; j < LocationTable.GetCount(); j++)
{
int iLocID = LocationTable[j];
CLocationDef *pLoc = pSystem->GetLocation(iLocID);
iTotal += LocationCriteria.AdjLocationWeight(pSystem, pLoc);
}
int iAverageChance = iTotal / LocationTable.GetCount();
// Now adjust the base chance
int iChance = iBaseChance * iAverageChance / 1000;
if (iChance <= 0)
continue;
// Add it to our table.
pEntry->Table.Insert(pType, iChance);
}
}
}
void CompileTradeData (CSpaceObject *pObj, SStationData *retAllStations, SItemData *retAllItems)
{
int i;
CDesignType *pType = pObj->GetType();
CStationType *pStationType = CStationType::AsType(pType);
if (pStationType == NULL || pStationType->GetTradingDesc() == NULL)
return;
// All prices in default currency (credits)
CEconomyType *pCurrency = CEconomyType::AsType(g_pUniverse->FindDesignType(DEFAULT_ECONOMY_UNID));
// Get the entry
bool bNew;
SStationTypeInfo *pStationInfo = retAllStations->SetAt(pStationType, &bNew);
if (bNew)
pStationInfo->pType = pStationType;
// Loop over all item types and see if that station buys or sells.
for (i = 0; i < g_pUniverse->GetItemTypeCount(); i++)
{
CItemType *pItemType = g_pUniverse->GetItemType(i);
CItem AnItem(pItemType, 1);
SItemTypeInfo *pItemInfo = NULL;
// See if the stations buys this
int iBuyPrice = (int)pCurrency->Exchange(pObj->GetDefaultEconomy(), pObj->GetBuyPrice(AnItem, CTradingDesc::FLAG_NO_DONATION));
if (iBuyPrice > 0)
{
// Add an entry for the station type recording that we buy this
// item type at the given price.
SItemTradeInfo *pItemEntry = pStationInfo->Buys.SetAt(pItemType, &bNew);
if (bNew)
pItemEntry->pItem = pItemType;
pItemEntry->Records.Insert(iBuyPrice);
// Add an entry for the item type recording that this station type
// buys the given item.
pItemInfo = retAllItems->SetAt(pItemType, &bNew);
if (bNew)
pItemInfo->pItem = pItemType;
SStationTradeInfo *pStationEntry = pItemInfo->BoughtBy.SetAt(pStationType, &bNew);
if (bNew)
pStationEntry->pStation = pStationType;
pStationEntry->Records.Insert(iBuyPrice);
}
// See if the station sells this
int iSellPrice = (int)pCurrency->Exchange(pObj->GetDefaultEconomy(), pObj->GetSellPrice(AnItem, 0));
if (iSellPrice > 0)
{
// Add an entry for the station type recording that we sell this
// item type at the given price.
SItemTradeInfo *pItemEntry = pStationInfo->Sells.SetAt(pItemType, &bNew);
if (bNew)
pItemEntry->pItem = pItemType;
pItemEntry->Records.Insert(iSellPrice);
// Add an entry for the item type recording that this station type
// buys the given item.
if (pItemInfo == NULL)
{
pItemInfo = retAllItems->SetAt(pItemType, &bNew);
if (bNew)
pItemInfo->pItem = pItemType;
}
SStationTradeInfo *pStationEntry = pItemInfo->SoldAt.SetAt(pStationType, &bNew);
if (bNew)
pStationEntry->pStation = pStationType;
pStationEntry->Records.Insert(iSellPrice);
}
}
}
void GenerateEncounterFrequency (CUniverse &Universe, CXMLElement *pCmdLine)
{
enum ETypes
{
outputFreq,
outputFillLocations,
};
int i, j;
// Options
int iSystemSample = pCmdLine->GetAttributeIntegerBounded(CONSTLIT("count"), 1, -1, 1);
bool bLogo = !pCmdLine->GetAttributeBool(CONSTLIT("noLogo"));
bool bAll = pCmdLine->GetAttributeBool(CONSTLIT("all"));
bool bRawData = pCmdLine->GetAttributeBool(CONSTLIT("rawData"));
ETypes iType;
if (pCmdLine->GetAttributeBool(CONSTLIT("fillLocations")))
iType = outputFillLocations;
else
iType = outputFreq;
// 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("fillLocations"))
&& !strEquals(sAttrib, CONSTLIT("rawData"))
&& !strEquals(sAttrib, CONSTLIT("encounterfreq")))
{
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
CSystemCreateStats Stats;
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, NULL, &Stats) != NOERROR)
{
printf("ERROR: Unable to create star system.\n");
return;
}
// Done with old system
Universe.DestroySystem(pSystem);
}
Universe.Reinit();
}
// Output based on type
if (iType == outputFreq)
{
// Generate a table for each encounter
TSortMap<CStationType *, SEncounterFreqEntry> EncounterFreq;
for (i = 0; i < Stats.GetEncounterTableCount(); i++)
{
const CSystemCreateStats::SEncounterTable &Table = Stats.GetEncounterTable(i);
// Skip if only planets and asteroids
if (!Table.bHasStation && !bAll)
continue;
// For each entry in the table, add to the frequency table
for (j = 0; j < Table.Table.GetCount(); j++)
{
CStationType *pEncounterType = Table.Table.GetAt(j);
int iChance = Table.Table.GetChance(j);
SEncounterFreqEntry *pEntry = EncounterFreq.SetAt(pEncounterType);
pEntry->iCount += Table.iCount;
pEntry->iTotalChance += Table.iCount * iChance;
if (pEntry->pMaxTable == NULL || iChance > pEntry->iMaxChance)
{
pEntry->pMaxTable = &Table;
pEntry->iMaxChance = iChance;
}
if (pEntry->pMinTable == NULL || iChance < pEntry->iMinChance)
{
pEntry->pMinTable = &Table;
pEntry->iMinChance = iChance;
}
}
}
// Output encounter frequency distribution
printf("Level\tCategory\tEncounter\tTotal Chances\tAverage Chance\tMin Chance\tMax Chance");
for (i = 0; i < Cols.GetCount(); i++)
printf("\t%s", Cols[i].GetASCIIZPointer());
printf("\n");
for (i = 0; i < EncounterFreq.GetCount(); i++)
{
CStationType *pEncounterType = EncounterFreq.GetKey(i);
int iAveWhole = EncounterFreq[i].iTotalChance / EncounterFreq[i].iCount;
int iAveFrac = 1000 * (EncounterFreq[i].iTotalChance % EncounterFreq[i].iCount) / EncounterFreq[i].iCount;
printf("%d\t%s\t%s\t%d\t%d.%03d\t%d\t%d",
pEncounterType->GetLevel(),
pEncounterType->GetDataField(CONSTLIT("category")).GetASCIIZPointer(),
pEncounterType->GetName().GetASCIIZPointer(),
EncounterFreq[i].iCount,
iAveWhole,
iAveFrac,
EncounterFreq[i].iMinChance,
EncounterFreq[i].iMaxChance);
for (j = 0; j < Cols.GetCount(); j++)
{
CString sValue = pEncounterType->GetDataField(Cols[j]);
printf("\t%s", sValue.GetASCIIZPointer());
}
printf("\n");
}
// Output raw data
if (bRawData)
{
// Loop over stats and output tables
for (i = 0; i < Stats.GetEncounterTableCount(); i++)
{
const CSystemCreateStats::SEncounterTable &Table = Stats.GetEncounterTable(i);
// Skip if only planets and asteroids
if (!Table.bHasStation && !bAll)
continue;
// Header
printf("LEVEL %d (%d location%s)\nSystem Type: %08x\nStations: %s\n",
Table.iLevel,
Table.iCount,
(Table.iCount == 1 ? "" : "s"),
Table.pSystemType->GetUNID(),
Table.sStationCriteria.GetASCIIZPointer());
// Location attributes
printf("Location: ");
for (j = 0; j < Table.LabelAttribs.GetCount(); j++)
{
if (j != 0)
printf(", ");
printf(Table.LabelAttribs[j].GetASCIIZPointer());
}
printf("\n");
// Entries
for (j = 0; j < Table.Table.GetCount(); j++)
printf("%s\t%d\n", Table.Table.GetAt(j)->GetName().GetASCIIZPointer(), Table.Table.GetChance(j));
printf("\n");
}
}
}
else if (iType == outputFillLocations)
{
printf("Level\tSystem\tEncounter\tChance\n");
for (i = 0; i < Stats.GetFillLocationsTableCount(); i++)
{
const CSystemCreateStats::SFillLocationsTable &Entry = Stats.GetFillLocationsTable(i);
for (j = 0; j < Entry.Table.GetCount(); j++)
{
int iPercent = (int)(1000.0 * Entry.Table.GetChance(j) / (Metric)Entry.Table.GetTotalChance());
printf("%d\t%s\t%s\t%d.%d\n",
Entry.iLevel,
Entry.sSystemName.GetASCIIZPointer(),
Entry.Table[j]->GetName().GetASCIIZPointer(),
iPercent / 10,
iPercent % 10);
}
}
}
}
