ALERROR CDesignCollection::CreateTemplateTypes (SDesignLoadCtx &Ctx)
// CreateTemplateTypes
//
// This is called inside of BindDesign to create all template types
{
ALERROR error;
int i;
// Create an appropriate context for running code
CCodeChainCtx CCCtx;
// Loop over all active types looking for templates.
// NOTE: We cannot use the type-specific arrays because they have not been
// set up yet (remember that we are inside of BindDesign).
for (i = 0; i < m_AllTypes.GetCount(); i++)
{
CDesignType *pTemplate = m_AllTypes.GetEntry(i);
if (pTemplate->GetType() != designTemplateType)
continue;
// Get the function to generate the type source
CString sSource;
SEventHandlerDesc Event;
if (pTemplate->FindEventHandler(GET_TYPE_SOURCE_EVENT, &Event))
{
ICCItem *pResult = CCCtx.Run(Event);
if (pResult->IsError())
{
Ctx.sError = strPatternSubst(CONSTLIT("GetTypeSource (%x): %s"), pTemplate->GetUNID(), pResult->GetStringValue());
return ERR_FAIL;
}
else if (pResult->IsNil())
sSource = NULL_STR;
else
sSource = pResult->GetStringValue();
CCCtx.Discard(pResult);
}
// Define the type
if (!sSource.IsBlank())
{
if (error = AddDynamicType(pTemplate->GetExtension(), pTemplate->GetUNID(), sSource, true, &Ctx.sError))
return error;
}
}
return NOERROR;
}
ALERROR GetEconomyUNIDOrDefault (CCodeChain &CC, ICCItem *pItem, DWORD *retdwUNID)
{
if (pItem == NULL || pItem->IsNil())
{
if (retdwUNID)
*retdwUNID = 0;
}
else if (pItem->IsInteger())
{
CDesignType *pType = g_pUniverse->FindDesignType(pItem->GetIntegerValue());
if (pType == NULL)
return ERR_FAIL;
if (retdwUNID)
*retdwUNID = pType->GetUNID();
}
else
{
CEconomyType *pEconomy = g_pUniverse->FindEconomyType(pItem->GetStringValue());
if (pEconomy == NULL)
return ERR_FAIL;
if (retdwUNID)
*retdwUNID = pEconomy->GetUNID();
}
return NOERROR;
}
ALERROR CDesignCollection::ResolveOverrides (SDesignLoadCtx &Ctx)
// ResolveOverrides
//
// Resolve all overrides
{
int i;
// Apply all overrides
for (i = 0; i < m_OverrideTypes.GetCount(); i++)
{
CDesignType *pOverride = m_OverrideTypes.GetEntry(i);
// Find the type that we are trying to override. If we can't find it
// then just continue without error (it means we're trying to override
// a type that doesn't currently exist).
CDesignType *pType = m_AllTypes.FindByUNID(pOverride->GetUNID());
if (pType == NULL)
continue;
// If this type is not already a clone then we need to clone it first
// (Because we never modify the original loaded type).
if (!pType->IsClone())
{
CDesignType *pClone;
pType->CreateClone(&pClone);
m_CreatedTypes.AddEntry(pClone);
pType = pClone;
}
// Now modify the type with the override
pType->MergeType(pOverride);
// Replace the original
m_AllTypes.AddOrReplaceEntry(pType);
}
// Done
return NOERROR;
}
void CDesignCollection::FireOnGlobalUpdate (int iTick)
// FireOnGlobalUpdate
//
// Types get a chance to do whatever they want once every 15 ticks.
{
int i;
CString sError;
for (i = 0; i < m_EventsCache[evtOnGlobalUpdate]->GetCount(); i++)
{
SEventHandlerDesc Event;
CDesignType *pType = m_EventsCache[evtOnGlobalUpdate]->GetEntry(i, &Event);
if ((((DWORD)iTick + pType->GetUNID()) % GLOBAL_ON_UPDATE_CYCLE) == 0)
pType->FireOnGlobalUpdate(Event);
}
}
void AccumulateSystem (CTopologyNode *pNode, CSystem *pSystem, TSortMap<DWORD, STypeInfo> &AllTypes)
{
int j;
int iSystemLevel = pSystem->GetLevel();
// 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
CDesignType *pType;
if ((pType = pObj->GetEncounterInfo()) || (pType = pObj->GetType()))
{
STypeInfo *pInfo = AllTypes.SetAt(pType->GetUNID());
pInfo->iTotalCount++;
pInfo->PerLevel[iSystemLevel]++;
}
// 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())
{
STypeInfo *pInfo = AllTypes.SetAt(Item.GetType()->GetUNID());
pInfo->iTotalCount += Item.GetCount();
pInfo->PerLevel[iSystemLevel] += Item.GetCount();
}
}
}
}
}
void OutputByShipClass (SItemTableCtx &Ctx, const SItemTypeList &ItemList, bool bShowUsage)
{
int i, j;
// Make a map of ship classes for each item
TSortMap<DWORD, TArray<CShipClass *>> ItemToShipClass;
for (i = 0; i < g_pUniverse->GetShipClassCount(); i++)
{
CShipClass *pClass = g_pUniverse->GetShipClass(i);
// Skip non-generic ones
if (!pClass->HasLiteralAttribute(CONSTLIT("genericClass")))
continue;
// Add the list of types used by the ship
TSortMap<DWORD, bool> TypesUsed;
pClass->AddTypesUsed(&TypesUsed);
// For each item type, add it to the map
for (j = 0; j < TypesUsed.GetCount(); j++)
{
CDesignType *pType = g_pUniverse->FindDesignType(TypesUsed.GetKey(j));
if (pType && pType->GetType() == designItemType)
{
TArray<CShipClass *> *pList = ItemToShipClass.SetAt(pType->GetUNID());
pList->Insert(pClass);
}
}
}
// If we want to show usage, then we print each item along with the
// ship classes using each item.
if (bShowUsage)
{
for (i = 0; i < ItemList.GetCount(); i++)
{
CItemType *pType = ItemList[i];
printf("%s\n", (LPSTR)pType->GetNounPhrase());
TArray<CShipClass *> *pList = ItemToShipClass.SetAt(pType->GetUNID());
for (j = 0; j < pList->GetCount(); j++)
printf("\t%s\n", (LPSTR)pList->GetAt(j)->GetName());
if (pList->GetCount() == 0)
printf("\t(none)\n");
printf("\n");
}
}
// Otherwise we categorize by ship class
else
{
// Now make a list of all ship classes that have our items
SByShipClassTypeList ByShipClassTable;
for (i = 0; i < ItemList.GetCount(); i++)
{
const CString &sKey = ItemList.GetKey(i);
CItemType *pType = ItemList[i];
// Loop over all ship classes
TArray<CShipClass *> *pList = ItemToShipClass.SetAt(pType->GetUNID());
for (j = 0; j < pList->GetCount(); j++)
{
CString sClassName = pList->GetAt(j)->GetName();
bool bNew;
SShipClassEntry *pEntry = ByShipClassTable.SetAt(sClassName, &bNew);
if (bNew)
pEntry->sShipClassName = sClassName;
pEntry->ItemTable.Insert(sKey, pType);
}
// If no ship class
if (pList->GetCount() == 0)
{
bool bNew;
SShipClassEntry *pEntry = ByShipClassTable.SetAt(CONSTLIT("(none)"), &bNew);
if (bNew)
pEntry->sShipClassName = CONSTLIT("(none)");
pEntry->ItemTable.Insert(sKey, pType);
}
}
// Now loop over all attributes
for (i = 0; i < ByShipClassTable.GetCount(); i++)
{
const SShipClassEntry &Entry = ByShipClassTable[i];
printf("%s\n\n", Entry.sShipClassName.GetASCIIZPointer());
OutputHeader(Ctx);
OutputTable(Ctx, Entry.ItemTable);
printf("\n");
}
}
}
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 GenerateTypeIslands (CUniverse &Universe, CXMLElement *pCmdLine)
{
int i, j;
bool bExcludeImages = true;
printf("TYPE ISLANDS\n");
printf("------------\n\n");
// Make a list of default types
#if 0
g_DefaultTypes.SetAt(0x00001001, true); // independent sovereign
g_DefaultTypes.SetAt(0x00001002, true); // Commonwealth sovereign
g_DefaultTypes.SetAt(0x00001003, true); // independent sovereign
g_DefaultTypes.SetAt(0x00001007, true); // ares sovereign
g_DefaultTypes.SetAt(0x0000100c, true); // sung slavers sovereign
g_DefaultTypes.SetAt(0x0000100f, true); // auton sovereign
g_DefaultTypes.SetAt(0x00001011, true); // corporate hierarchy
g_DefaultTypes.SetAt(0x00004027, true); // container of frozen supplies
g_DefaultTypes.SetAt(0x0000402c, true); // pteracnium ore
g_DefaultTypes.SetAt(0x000040ae, true); // helium3 reactor assembly
g_DefaultTypes.SetAt(0x000040af, true); // pteracnium fuel
g_DefaultTypes.SetAt(0x000040ca, true); // lancer cannon
g_DefaultTypes.SetAt(0x000040e2, true); // worldship armor
g_DefaultTypes.SetAt(0x00004100, true); // xenotite ore
g_DefaultTypes.SetAt(0x00004109, true); // SN2500 reactor
g_DefaultTypes.SetAt(0x00004167, true); // tetramite ore
g_DefaultTypes.SetAt(0x00005004, true); // wreck ejecta
g_DefaultTypes.SetAt(0x0000500c, true); // blast explosion 2
g_DefaultTypes.SetAt(0x0000500d, true); // blast explosion 3
g_DefaultTypes.SetAt(0x0000500e, true); // blast explosion 4
g_DefaultTypes.SetAt(0x0000500f, true); // thermo explosion 1
g_DefaultTypes.SetAt(0x00005011, true); // thermo explosion 3
g_DefaultTypes.SetAt(0x00005012, true); // thermo explosion 4
g_DefaultTypes.SetAt(0x00009004, true); // shield effect
g_DefaultTypes.SetAt(0x00009007, true); // explosion effect
g_DefaultTypes.SetAt(0x0000900a, true); // fire effect
g_DefaultTypes.SetAt(0x0000A003, true); // dsAbandonedStation
g_DefaultTypes.SetAt(0x0000a017, true); // dock screen?
g_DefaultTypes.SetAt(0x001a200c, true); // wreck of the CSC Europa
g_DefaultTypes.SetAt(0x001a200e, true); // sandstorm wreck
g_DefaultTypes.SetAt(0x001c1002, true); // ares sect in Heretic
g_DefaultTypes.SetAt(0x08020102, true); // huari empire sovereign
g_DefaultTypes.SetAt(0x08040140, true); // gaian processor station
#endif
// Create a reverse index of all type dependencies
ReverseIndexMap ReverseIndex;
for (i = 0; i < Universe.GetDesignTypeCount(); i++)
{
CDesignType *pType = Universe.GetDesignType(i);
// Get the list of UNIDs that this type uses
TSortMap<DWORD, bool> TypesUsed;
pType->AddTypesUsed(&TypesUsed);
for (j = 0; j < TypesUsed.GetCount(); j++)
{
CDesignType *pRequired = Universe.FindDesignType(TypesUsed.GetKey(j));
if (pRequired == NULL)
continue;
// Add to reverse index
TArray<DWORD> *pList = ReverseIndex.SetAt(pRequired->GetUNID());
pList->Insert(pType->GetUNID());
}
}
// We create a list of islands. In each island, all the types refer to
// each other and don't refer to types on any other island.
TArray<IslandMap> AllIslands;
// Loop over all types and add them to an island.
for (i = 0; i < Universe.GetDesignTypeCount(); i++)
{
CDesignType *pType = Universe.GetDesignType(i);
// Exclude images
if (bExcludeImages && pType->GetType() == designImage)
continue;
if (pType->GetType() == designShipTable)
continue;
// Exclude default types
if (g_DefaultTypes.Find(pType->GetUNID()))
continue;
// If this type is already on one of the islands, then we skip it.
#if 0
bool bFound = false;
for (j = 0; j < AllIslands.GetCount(); j++)
if (AllIslands[j].Find(pType->GetUNID()))
{
bFound = true;
break;
}
if (bFound)
continue;
#endif
// Since this type is not on any island, we add start a new island and
// add all related types to it.
IslandMap *pIsland = AllIslands.Insert();
AddTypeToIsland(Universe, ReverseIndex, pIsland, pType);
// Print
printf("ISLAND %s\n", (char *)GetTypeDesc(pType));
for (j = 0; j < pIsland->GetCount(); j++)
{
CDesignType *pType = Universe.FindDesignType(pIsland->GetKey(j));
if (pType == NULL)
continue;
printf("%s\n", (char *)GetTypeDesc(pType));
}
printf("\n");
}
}
void GenerateTypeDependencies (CUniverse &Universe, CXMLElement *pCmdLine)
{
int i, j;
bool bRecursive = pCmdLine->GetAttributeBool(CONSTLIT("recursive"));
bool bReverse = pCmdLine->GetAttributeBool(CONSTLIT("reverse"));
// Create a reverse index of all type dependencies
TSortMap<DWORD, TArray<DWORD> > ReverseIndex;
// Types and what they use
if (!bReverse)
{
printf("TYPES AND WHAT THEY USE\n");
printf("-----------------------\n\n");
}
for (i = 0; i < Universe.GetDesignTypeCount(); i++)
{
CDesignType *pType = Universe.GetDesignType(i);
if (!bReverse)
printf("%s\n", (char *)GetTypeDesc(pType));
// Get the list of UNIDs that this type uses
TSortMap<DWORD, bool> TypesUsed;
if (bRecursive)
AddTypesUsedRecursive(Universe, pType->GetUNID(), &TypesUsed);
else
pType->AddTypesUsed(&TypesUsed);
// Output the list
for (j = 0; j < TypesUsed.GetCount(); j++)
{
CDesignType *pRequired = Universe.FindDesignType(TypesUsed.GetKey(j));
if (pRequired == NULL)
continue;
if (!bReverse)
printf("\t%s\n", (char *)GetTypeDesc(pRequired));
// Add to reverse index
TArray<DWORD> *pList = ReverseIndex.SetAt(pRequired->GetUNID());
pList->Insert(pType->GetUNID());
}
}
// Types and what depends on them
if (bReverse)
{
printf("\nTYPES AND WHAT USES THEM\n");
printf( "------------------------\n\n");
for (i = 0; i < ReverseIndex.GetCount(); i++)
{
CDesignType *pType = Universe.FindDesignType(ReverseIndex.GetKey(i));
if (pType == NULL)
continue;
printf("%s\n", (char *)GetTypeDesc(pType));
TArray<DWORD> &List = ReverseIndex.GetValue(i);
for (j = 0; j < List.GetCount(); j++)
{
CDesignType *pRequiredBy = Universe.FindDesignType(List[j]);
if (pRequiredBy)
printf("\t%s\n", (char *)GetTypeDesc(pRequiredBy));
}
}
}
}
void GenerateTypeTable (CUniverse &Universe, CXMLElement *pCmdLine)
{
int i, j;
// Get the criteria from the command line.
CString sCriteria = pCmdLine->GetAttribute(CRITERIA_ATTRIB);
// Parse it
CDesignTypeCriteria Criteria;
if (CDesignTypeCriteria::ParseCriteria(sCriteria, &Criteria) != NOERROR)
{
printf("ERROR: Unable to parse criteria.\n");
return;
}
// Generate a table of all matching types
TSortMap<CString, CDesignType *> Table;
// Loop over all items for this level and add them to
// a sorted table.
for (i = 0; i < Universe.GetDesignTypeCount(); i++)
{
CDesignType *pType = Universe.GetDesignType(i);
int iLevel = pType->GetLevel();
if (!pType->MatchesCriteria(Criteria))
continue;
// Get the name
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%08x",
iLevel,
sName.GetASCIIZPointer(),
pType->GetUNID());
Table.Insert(CString(szBuffer), pType);
}
// Generate a list of columns to display
TArray<CString> Cols;
Cols.Insert(FIELD_LEVEL);
Cols.Insert(FIELD_NAME);
for (i = 0; i < pCmdLine->GetAttributeCount(); i++)
{
CString sAttrib = pCmdLine->GetAttributeName(i);
if (!IsMainCommandParam(sAttrib)
&& !strEquals(sAttrib, CONSTLIT("typetable")))
{
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 (LoadDesignTypeStats(Universe.GetDesignCollection().GetAdventureUNID(), &TotalCount) != NOERROR)
{
printf("ERROR: Unable to load type count table.\n");
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
CCodeChainCtx CCCtx;
for (i = 0; i < Table.GetCount(); i++)
{
CDesignType *pType = Table[i];
for (j = 0; j < Cols.GetCount(); j++)
{
if (j != 0)
printf("\t");
const CString &sField = Cols[j];
// Format and output
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
{
ICCItem *pResult = pType->GetProperty(CCCtx, sField);
CString sValue = pResult->Print(&g_pUniverse->GetCC(), PRFLAG_NO_QUOTES | PRFLAG_ENCODE_FOR_DISPLAY);
pResult->Discard(&g_pUniverse->GetCC());
printf(sValue.GetASCIIZPointer());
}
}
printf("\n");
}
printf("\n");
}
else
printf("No entries match criteria.\n");
}
void GenerateSimTables (CUniverse &Universe, CXMLElement *pCmdLine)
{
ALERROR error;
int i, j, k;
int iSystemSample = pCmdLine->GetAttributeInteger(CONSTLIT("count"));
if (iSystemSample == 0)
iSystemSample = DEFAULT_SYSTEM_SAMPLE;
// Keep track of stats for each type
TSortMap<DWORD, STypeStats> AllStats;
for (i = 0; i < iSystemSample; i++)
{
TSortMap<DWORD, STypeInfo> AllTypes;
printf("sample %d...\n", i+1);
// Initialize the game
CString sError;
if (error = Universe.InitGame(0, &sError))
{
printf("%s\n", sError.GetASCIIZPointer());
return;
}
// Loop over all nodes
for (j = 0; j < Universe.GetTopologyNodeCount(); j++)
{
CTopologyNode *pNode = Universe.GetTopologyNode(j);
// Skip end game nodes
if (pNode->IsEndGame())
continue;
// Create the system
CSystem *pSystem;
if (error = Universe.CreateStarSystem(pNode, &pSystem, &sError))
{
printf("ERROR: Unable to create star system: %s\n", sError.GetASCIIZPointer());
return;
}
// Accumulate
AccumulateSystem(pNode, pSystem, AllTypes);
// Done with old system
Universe.DestroySystem(pSystem);
}
// Now accumulate all stats
for (j = 0; j < Universe.GetDesignTypeCount(); j++)
{
CDesignType *pType = Universe.GetDesignType(j);
STypeStats *pStats = AllStats.SetAt(pType->GetUNID());
STypeInfo *pTypeInfo = AllTypes.GetAt(pType->GetUNID());
if (pTypeInfo)
{
pStats->PerGame.Insert(pTypeInfo->iTotalCount);
for (k = 0; k < MAX_TECH_LEVEL; k++)
pStats->PerLevel[k].Insert(pTypeInfo->PerLevel[k]);
}
else
{
pStats->PerGame.Insert(0);
for (k = 0; k < MAX_TECH_LEVEL; k++)
pStats->PerLevel[k].Insert(0);
}
}
Universe.Reinit();
}
// Output
if (error = OutputTypeTable(AllStats, iSystemSample))
return;
// Create a table with the sum of all items for the game
printf("Total count statistic computed.\n");
}
ALERROR CDesignCollection::BindDesign (SDesignLoadCtx &Ctx)
// BindDesign
//
// Bind the design collection so that design types point the appropriate
// pointers by UNID
{
ALERROR error;
int i, j;
// Unbind everything
for (i = 0; i < m_AllTypes.GetCount(); i++)
m_AllTypes.GetEntry(i)->UnbindDesign();
m_AllTypes.DeleteAll();
// Reset the bind tables
for (i = 0; i < designCount; i++)
m_ByType[i].DeleteAll();
// We start with all the base types
for (i = 0; i < m_Base.GetCount(); i++)
m_AllTypes.AddEntry(m_Base.GetEntry(i));
// Start with base topology
m_pTopology = &m_BaseTopology;
m_pAdventureExtension = NULL;
// Now add all enabled extensions
for (i = 0; i < GetExtensionCount(); i++)
{
SExtensionDesc *pExtension = GetExtension(i);
if (pExtension->bEnabled)
{
// Add design elements in extension
for (j = 0; j < pExtension->Table.GetCount(); j++)
{
CDesignType *pEntry = pExtension->Table.GetEntry(j);
m_AllTypes.AddOrReplaceEntry(pEntry);
}
// Handle adventure extensions
if (pExtension->iType == extAdventure)
{
// Keep track of extension
m_pAdventureExtension = pExtension;
// Add topology
m_pTopology = &pExtension->Topology;
}
}
else
{
if (pExtension->iType == extAdventure)
{
DWORD dwCoverImage = 0;
// Adventure desc elements are added even if not enabled
for (j = 0; j < pExtension->Table.GetCount(); j++)
{
CDesignType *pEntry = pExtension->Table.GetEntry(j);
if (pEntry->GetType() == designAdventureDesc)
{
m_AllTypes.AddOrReplaceEntry(pEntry);
// Get the cover image used by the adventure, because
// we need to load that too.
CAdventureDesc *pDesc = CAdventureDesc::AsType(pEntry);
dwCoverImage = pDesc->GetBackgroundUNID();
}
}
// Make sure we load the cover image
if (dwCoverImage)
{
for (j = 0; j < pExtension->Table.GetCount(); j++)
{
CDesignType *pEntry = pExtension->Table.GetEntry(j);
if (pEntry->GetUNID() == dwCoverImage)
m_AllTypes.AddOrReplaceEntry(pEntry);
}
}
}
}
}
// If this is a new game, then create all the Template types
if (Ctx.bNewGame)
{
m_DynamicUNIDs.DeleteAll();
m_DynamicTypes.DeleteAll();
if (error = FireOnGlobalTypesInit(Ctx))
return error;
if (error = CreateTemplateTypes(Ctx))
return error;
}
// Add all the dynamic types. These came either from the saved game file or
// from the Template types above.
for (i = 0; i < m_DynamicTypes.GetCount(); i++)
m_AllTypes.AddOrReplaceEntry(m_DynamicTypes.GetType(i));
// Initialize the byType lists
for (i = 0; i < m_AllTypes.GetCount(); i++)
{
CDesignType *pEntry = m_AllTypes.GetEntry(i);
m_ByType[pEntry->GetType()].AddEntry(pEntry);
}
// Set our adventure desc as current; since adventure descs are always
// loaded this is the only thing that we can use to tell if we should
// call global events.
//
// This must happen after Unbind (because that clears it) and before
// PrepareBindDesign.
//
// NOTE: m_pAdventureDesc can be NULL (e.g., in the intro screen).
if (m_pAdventureDesc)
m_pAdventureDesc->SetCurrentAdventure();
// Cache a map between currency name and economy type
// We need to do this before Bind because some types will lookup
// a currency name during Bind.
m_EconomyIndex.DeleteAll();
for (i = 0; i < GetCount(designEconomyType); i++)
{
CEconomyType *pEcon = CEconomyType::AsType(GetEntry(designEconomyType, i));
const CString &sName = pEcon->GetSID();
bool bUnique;
CEconomyType **ppDest = m_EconomyIndex.SetAt(sName, &bUnique);
if (!bUnique)
return pEcon->ComposeLoadError(Ctx, CONSTLIT("Currency ID must be unique"));
*ppDest = pEcon;
}
// Prepare to bind. This is used by design elements
// that need two passes to bind.
for (i = 0; i < m_AllTypes.GetCount(); i++)
{
CDesignType *pEntry = m_AllTypes.GetEntry(i);
if (error = pEntry->PrepareBindDesign(Ctx))
return error;
}
// Now call Bind on all active design entries
for (i = 0; i < evtCount; i++)
m_EventsCache[i]->DeleteAll();
for (i = 0; i < m_AllTypes.GetCount(); i++)
{
CDesignType *pEntry = m_AllTypes.GetEntry(i);
if (error = pEntry->BindDesign(Ctx))
return error;
// Cache some global events. We keep track of the global events for
// all types so that we can access them faster.
CacheGlobalEvents(pEntry);
}
// Finish binding. This pass is used by design elements
// that need to do stuff after all designs are bound.
for (i = 0; i < m_AllTypes.GetCount(); i++)
{
CDesignType *pEntry = m_AllTypes.GetEntry(i);
if (error = pEntry->FinishBindDesign(Ctx))
return error;
}
return NOERROR;
}
ALERROR CExtension::LoadDesignType (SDesignLoadCtx &Ctx, CXMLElement *pDesc, CDesignType **retpType)
// LoadDesignType
//
// Loads a standard design type
{
ALERROR error;
CDesignType *pType = NULL;
// Load topology
if (strEquals(pDesc->GetTag(), STAR_SYSTEM_TOPOLOGY_TAG)
|| strEquals(pDesc->GetTag(), SYSTEM_TOPOLOGY_TAG))
{
if (error = m_Topology.LoadFromXML(Ctx, pDesc, NULL, NULL_STR))
return error;
}
// <Sound>
else if (strEquals(pDesc->GetTag(), SOUND_TAG))
return LoadSoundElement(Ctx, pDesc);
// <Globals>
else if (strEquals(pDesc->GetTag(), GLOBALS_TAG))
return LoadGlobalsElement(Ctx, pDesc);
// <Library>
else if (strEquals(pDesc->GetTag(), LIBRARY_TAG))
return LoadLibraryElement(Ctx, pDesc);
// <Module>
else if (strEquals(pDesc->GetTag(), MODULE_TAG))
return LoadModuleElement(Ctx, pDesc);
// <Modules>
else if (strEquals(pDesc->GetTag(), MODULES_TAG))
return LoadModulesElement(Ctx, pDesc);
// Load standard design elements
else
{
if (error = CDesignType::CreateFromXML(Ctx, pDesc, &pType))
return error;
DWORD dwUNID = pType->GetUNID();
// Can't use the reserved range
if (IsReservedUNID(dwUNID))
{
Ctx.sError = strPatternSubst(CONSTLIT("Cannot use reserved UNID: %x"), dwUNID);
return ERR_FAIL;
}
// Add to our list
if (error = m_DesignTypes.AddEntry(pType))
{
if (error == ERR_OUTOFROOM)
{
// For backwards compatibility with earlier versions, we
// disable this message.
if (Ctx.GetAPIVersion() >= 12)
{
Ctx.sError = strPatternSubst(CONSTLIT("Duplicate UNID: %x"), dwUNID);
return error;
}
}
else
{
Ctx.sError = strPatternSubst(CONSTLIT("Error adding design entry UNID: %x"), dwUNID);
return error;
}
}
// Let this type add external definitions
pType->AddExternals(&m_Externals);
}
// Done
if (retpType)
*retpType = pType;
return NOERROR;
}