ALERROR CEventHandler::InitFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc)
// InitFromXML
//
// Load all handlers
{
int i;
for (i = 0; i < pDesc->GetContentElementCount(); i++)
{
CXMLElement *pHandler = pDesc->GetContentElement(i);
ICCItem *pCode = g_pUniverse->GetCC().Link(pHandler->GetContentText(0), 0, NULL);
if (pCode->IsError())
{
Ctx.sError = strPatternSubst("<%s> event: %s", pHandler->GetTag(), pCode->GetStringValue());
return ERR_FAIL;
}
// If this is an old extension, then make sure the code is not using the
// gStation variable, because we no longer support it
if (Ctx.pExtension && Ctx.pExtension->dwVersion < 2)
{
if (g_pUniverse->GetCC().HasIdentifier(pCode, CONSTLIT("gStation")))
{
Ctx.sError = CONSTLIT("gStation variable has been deprecated--use gSource instead.");
return ERR_FAIL;
}
}
// Done
m_Handlers.Insert(pHandler->GetTag(), pCode);
}
return NOERROR;
}
CString CDamageSource::GetDamageCauseNounPhrase (DWORD dwFlags)
// GetDamageCauseNounPhrase
//
// Returns the name of the damage source
{
if (m_pSource)
return m_pSource->GetDamageCauseNounPhrase(dwFlags);
else if (!m_sSourceName.IsBlank())
return ::ComposeNounPhrase(m_sSourceName, 1, NULL_STR, m_dwSourceNameFlags, dwFlags);
else
return CONSTLIT("damage");
}
ALERROR CTransmuterController::OnBoot (char *pszCommandLine, SHIOptions *retOptions, CString *retsError)
// OnBoot
//
// Controller must initialize all option values
{
CString sError;
// Set our basic application settings
retOptions->sAppName = CONSTLIT("Transmuter");
retOptions->sClassName = CONSTLIT("transmuter_class");
retOptions->sAppData = CONSTLIT("Kronosaur\\Transmuter");
retOptions->hIcon = ::LoadIcon(NULL, MAKEINTRESOURCE(IDI_TRANSMUTER));
// Set our default directory
CString sCurDir = pathGetExecutablePath(NULL);
::SetCurrentDirectory(sCurDir.GetASCIIZPointer());
return NOERROR;
}
ALERROR CEnhancerClass::CreateFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc, CItemType *pType, CDeviceClass **retpDevice)
// CreateFromXML
//
// Load device data from XML
{
ALERROR error;
CEnhancerClass *pDevice;
pDevice = new CEnhancerClass;
if (pDevice == NULL)
return ERR_MEMORY;
if (error = pDevice->InitDeviceFromXML(Ctx, pDesc, pType))
return error;
// The old style is to have an array of damage adj; the new way is to just
// have a single damage adj and a criteria
int iDamageAdjCount;
LoadDamageAdj(pDesc, DAMAGE_ADJ_ATTRIB, pDevice->m_iDamageAdjArray, &iDamageAdjCount);
if (iDamageAdjCount)
pDevice->m_bUseArray = true;
else
{
pDevice->m_iDamageAdj = pDesc->GetAttributeInteger(HP_BONUS_ATTRIB);
pDevice->m_bUseArray = false;
}
pDevice->m_iPowerUse = pDesc->GetAttributeInteger(POWER_USE_ATTRIB);
pDevice->m_sEnhancementType = pDesc->GetAttribute(ENHANCEMENT_TYPE_ATTRIB);
pDevice->m_iActivateAdj = pDesc->GetAttributeIntegerBounded(ACTIVATE_ADJ_ATTRIB, 1, -1, 100);
pDevice->m_iMinActivateDelay = pDesc->GetAttributeIntegerBounded(MIN_ACTIVATE_DELAY_ATTRIB, 0, -1, 0);
pDevice->m_iMaxActivateDelay = pDesc->GetAttributeIntegerBounded(MAX_ACTIVATE_DELAY_ATTRIB, 0, -1, 0);
// Load the item criteria
CString sCriteria;
if (!pDesc->FindAttribute(CRITERIA_ATTRIB, &sCriteria))
sCriteria = CONSTLIT("w");
CItem::ParseCriteria(sCriteria, &pDevice->m_Criteria);
// Done
*retpDevice = pDevice;
return NOERROR;
}
CString CDeviceClass::GetReference (CItemCtx &Ctx, int iVariant, DWORD dwFlags)
// GetReference
//
// Returns reference string
{
CString sReference;
// For a device we always add power and other properties.
// (If iVariant != -1 then it means that we're looking for reference on a
// missile or someting).
if (iVariant == -1)
{
CInstalledDevice *pDevice = Ctx.GetDevice();
// Start with power requirements
AppendReferenceString(&sReference, GetReferencePower(Ctx));
// Non-standard slots
if (GetSlotsRequired() != 1)
AppendReferenceString(&sReference, strPatternSubst(CONSTLIT("%d Slots"), GetSlotsRequired()));
// External devices
if (IsExternal() || (pDevice && pDevice->IsExternal()))
AppendReferenceString(&sReference, CONSTLIT("External"));
}
// Combine with our subclass
AppendReferenceString(&sReference, OnGetReference(Ctx, iVariant, dwFlags));
return sReference;
}
void CHumanInterface::HardCrash (const CString &sProgramState)
// HardCrash
//
// Report an error
{
CString sSessionMessage;
try
{
if (m_pCurSession)
m_pCurSession->HIReportHardCrash(&sSessionMessage);
}
catch (...)
{
sSessionMessage = CONSTLIT("Unable to obtain crash report from session.");
}
CString sMessage = strPatternSubst(CONSTLIT(
"Unable to continue due to program error.\r\n\r\n"
"program state: %s\r\n"
"%s"
"\r\n\r\nPlease contact [email protected] with a copy of Debug.log and your save file. "
"We are sorry for the inconvenience.\r\n"),
sProgramState,
sSessionMessage
);
kernelDebugLogMessage(sMessage);
ShowHardCrashSession(CONSTLIT("Transcendence System Crash"), sMessage);
// Ask the controller to post a crash report
CString *pCrashReport = new CString(::kernelGetSessionDebugLog());
if (HICommand(CONSTLIT("cmdPostCrashReport"), pCrashReport) == ERR_NOTFOUND)
delete pCrashReport;
}
ALERROR ITopologyProcessor::CreateFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc, const CString &sUNID, ITopologyProcessor **retpProc)
// CreateFromXML
//
// Creates a new processor based on the XML tag
{
ALERROR error;
ITopologyProcessor *pProc;
// Create the approprate class
if (strEquals(pDesc->GetTag(), ATTRIBUTES_TAG))
pProc = new CApplySystemProc;
else if (strEquals(pDesc->GetTag(), CONQUER_NODES_TAG))
pProc = new CConquerNodesProc;
else if (strEquals(pDesc->GetTag(), DISTRIBUTE_NODES_TAG))
pProc = new CDistributeNodesProc;
else if (strEquals(pDesc->GetTag(), FILL_NODES_TAG))
pProc = new CFillNodesProc;
else if (strEquals(pDesc->GetTag(), GROUP_TAG))
pProc = new CGroupTopologyProc;
else if (strEquals(pDesc->GetTag(), LOCATE_NODES_TAG))
pProc = new CLocateNodesProc;
else if (strEquals(pDesc->GetTag(), PARTITION_NODES_TAG))
pProc = new CPartitionNodesProc;
else if (strEquals(pDesc->GetTag(), RANDOM_POINTS_TAG))
pProc = new CRandomPointsProc;
else if (strEquals(pDesc->GetTag(), SYSTEM_TAG))
pProc = new CApplySystemProc;
else if (strEquals(pDesc->GetTag(), TABLE_TAG))
pProc = new CTableTopologyProc;
else
{
Ctx.sError = strPatternSubst(CONSTLIT("Unknown topology processor element: <%s>"), pDesc->GetTag());
return ERR_FAIL;
}
// Load it
if (error = pProc->InitFromXML(Ctx, pDesc, sUNID))
return error;
// Done
*retpProc = pProc;
return NOERROR;
}
void CTranscendenceWnd::PlayerDestroyed (const CString &sText, bool bResurrectionPending)
// PlayerDestroyed
//
// This method gets called when the player is destroyed
{
// Clean up
HideCommsTargetMenu();
m_CurrentPicker = pickNone;
m_CurrentMenu = menuNone;
m_bAutopilot = false;
m_bShowingMap = false;
if (m_State == gsDocked)
GetPlayer()->Undock();
// Update display
CString sMsg = sText;
if (strEquals(strWord(sMsg, 0), CONSTLIT("was")))
sMsg = strSubString(sMsg, 4, -1);
sMsg.Capitalize(CString::capFirstLetter);
DisplayMessage(sMsg);
UpdateArmorDisplay();
// If we are insured, then set our state so that we come back to life
if (bResurrectionPending)
{
// Prepare resurrect
m_State = gsDestroyed;
m_iCountdown = TICKS_AFTER_DESTROYED;
}
// Otherwise, proceed with destruction
else
{
// Done with ship screens
CleanUpPlayerShip();
// Player destroyed
m_State = gsDestroyed;
m_iCountdown = TICKS_AFTER_DESTROYED;
}
}
bool CSteamCtx::ValidateConnected (CString *retsError) const
// ValidateConnected
//
// Make sure we are connected
{
if (!m_bConnected)
{
if (retsError) *retsError = CONSTLIT("Not connected to Steam service.");
return false;
}
return true;
}
ALERROR CObjectImage::Exists (SDesignLoadCtx &Ctx)
// Exists
//
// Returns TRUE if the appropriate resources exist
{
if (m_pBitmap)
return NOERROR;
if (!m_sBitmap.IsBlank() && !Ctx.pResDb->ImageExists(NULL_STR, m_sBitmap))
{
Ctx.sError = strPatternSubst(CONSTLIT("Unable to find image: '%s'"), m_sBitmap);
return ERR_FAIL;
}
if (!m_sBitmask.IsBlank() && !Ctx.pResDb->ImageExists(NULL_STR, m_sBitmask))
{
Ctx.sError = strPatternSubst(CONSTLIT("Unable to find image: '%s'"), m_sBitmask);
return ERR_FAIL;
}
return NOERROR;
}
void CLoginSession::CmdSignIn (void)
// CmdSignIn
//
// Sign in the user
{
CUIHelper Helper(m_HI);
// Get the fields
CString sUsername = GetPropertyString(ID_CTRL_USERNAME, PROP_TEXT);
CString sPassword = GetPropertyString(ID_CTRL_PASSWORD, PROP_TEXT);
bool bAutoSignIn = GetPropertyBool(ID_CTRL_AUTO_SIGN_IN, PROP_CHECKED);
// Get the text for the username. If blank, then we have an error.
if (sUsername.IsBlank())
{
Helper.CreateInputErrorMessage(this, m_rcInputError, CONSTLIT("Username Missing"), CONSTLIT("You must have a username to sign in."));
return;
}
// Register the name
m_HI.AddBackgroundTask(new CSignInUserTask(m_HI, m_Service, sUsername, sPassword, bAutoSignIn), this, CMD_SIGN_IN_COMPLETE);
// Disable controls
SetPropertyBool(ID_CTRL_USERNAME, PROP_ENABLED, false);
SetPropertyBool(ID_CTRL_PASSWORD, PROP_ENABLED, false);
SetPropertyBool(ID_CTRL_MAIN_ACTION, PROP_ENABLED, false);
SetPropertyBool(ID_CTRL_AUTO_SIGN_IN, PROP_ENABLED, false);
SetPropertyBool(ID_CTRL_REGISTER, PROP_ENABLED, false);
SetPropertyBool(ID_CTRL_PASSWORD_RESET, PROP_ENABLED, false);
}
bool CEnergyFieldType::FindDataField (const CString &sField, CString *retsValue)
// FindDataField
//
// Returns meta-data
{
int i;
if (strEquals(sField, FIELD_WEAPON_SUPPRESS))
{
if (m_WeaponSuppress.IsEmpty())
*retsValue = NULL_STR;
else
{
*retsValue = CONSTLIT("=(");
bool bNeedSeparator = false;
for (i = 0; i < damageCount; i++)
if (m_WeaponSuppress.InSet(i))
{
if (bNeedSeparator)
retsValue->Append(CONSTLIT(" "));
retsValue->Append(::GetDamageType((DamageTypes)i));
bNeedSeparator = true;
}
retsValue->Append(CONSTLIT(")"));
}
}
else
return CDesignType::FindDataField(sField, retsValue);
return true;
}
ALERROR CRandomItems::LoadFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc)
// LoadFromXML
//
// Load from XML
{
ALERROR error;
CString sCriteria = pDesc->GetAttribute(CRITERIA_ATTRIB);
if (sCriteria.IsBlank())
{
CString sAttributes = pDesc->GetAttribute(ATTRIBUTES_ATTRIB);
if (sAttributes.IsBlank())
sAttributes = pDesc->GetAttribute(MODIFIERS_ATTRIB);
sCriteria = strPatternSubst(CONSTLIT("%s %s"), pDesc->GetAttribute(CATEGORIES_ATTRIB), sAttributes);
}
CItem::ParseCriteria(sCriteria, &m_Criteria);
m_sLevelFrequency = pDesc->GetAttribute(LEVEL_FREQUENCY_ATTRIB);
m_bDynamicLevelFrequency = (strFind(m_sLevelFrequency, CONSTLIT(":")) != -1);
m_iDynamicLevel = 0;
m_iLevel = pDesc->GetAttributeInteger(LEVEL_ATTRIB);
m_iLevelCurve = pDesc->GetAttributeInteger(LEVEL_CURVE_ATTRIB);
m_iDamaged = pDesc->GetAttributeInteger(DAMAGED_ATTRIB);
if (error = m_Enhanced.InitFromXML(Ctx, pDesc))
return error;
m_Table = NULL;
m_iCount = 0;
return NOERROR;
}
ALERROR CObjectImageArray::InitFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc, bool bResolveNow)
// InitFromXML
//
// Create from XML description
{
// Initialize basic info
m_rcImage.left = pDesc->GetAttributeInteger(CONSTLIT(g_ImageXAttrib));
m_rcImage.top = pDesc->GetAttributeInteger(CONSTLIT(g_ImageYAttrib));
m_rcImage.right = m_rcImage.left + pDesc->GetAttributeInteger(CONSTLIT(g_ImageWidthAttrib));
m_rcImage.bottom = m_rcImage.top + pDesc->GetAttributeInteger(CONSTLIT(g_ImageHeightAttrib));
m_iFrameCount = pDesc->GetAttributeInteger(CONSTLIT(g_ImageFrameCountAttrib));
m_iRotationCount = pDesc->GetAttributeInteger(ROTATION_COUNT_ATTRIB);
if (m_iRotationCount <= 0)
m_iRotationCount = 1;
m_iTicksPerFrame = pDesc->GetAttributeInteger(CONSTLIT(g_ImageTicksPerFrameAttrib));
if (m_iTicksPerFrame <= 0 && m_iFrameCount > 1)
m_iTicksPerFrame = 1;
m_iFlashTicks = pDesc->GetAttributeInteger(FLASH_TICKS_ATTRIB);
CString sBlending = pDesc->GetAttribute(BLENDING_ATTRIB);
if (strEquals(sBlending, LIGHTEN_BLENDING))
m_iBlending = blendLighten;
else
m_iBlending = blendNormal;
// Compute rotation offsets
m_iRotationOffset = pDesc->GetAttributeInteger(ROTATE_OFFSET_ATTRIB);
if (m_iRotationOffset)
ComputeRotationOffsets();
else
{
int xOffset = pDesc->GetAttributeInteger(X_OFFSET_ATTRIB);
int yOffset = pDesc->GetAttributeInteger(Y_OFFSET_ATTRIB);
if (xOffset != 0 || yOffset != 0)
ComputeRotationOffsets(xOffset, yOffset);
}
// Get the image from the universe
m_dwBitmapUNID = LoadUNID(Ctx, pDesc->GetAttribute(CONSTLIT(g_ImageIDAttrib)));
if (bResolveNow)
m_pImage = g_pUniverse->FindLibraryImage(m_dwBitmapUNID);
else
m_pImage = NULL;
return NOERROR;
}
ALERROR CSingleParticleEffectCreator::OnEffectCreateFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc, const CString &sUNID)
// OnEffectCreateFromXML
//
// Initializes from XML
{
ALERROR error;
CString sStyle = pDesc->GetAttribute(STYLE_ATTRIB);
if (sStyle.IsBlank() || strEquals(sStyle, STYLE_PLAIN))
m_iStyle = paintPlain;
else if (strEquals(sStyle, STYLE_FLAME))
m_iStyle = paintFlame;
else if (strEquals(sStyle, STYLE_SMOKE))
m_iStyle = paintSmoke;
else if (strEquals(sStyle, STYLE_LINE))
m_iStyle = paintLine;
else
{
Ctx.sError = CONSTLIT("Invalid SingleParticle style");
return ERR_FAIL;
}
CString sRange;
if (pDesc->FindAttribute(MAX_WIDTH_ATTRIB, &sRange))
{
if (error = m_MaxWidth.LoadFromXML(sRange))
return error;
}
else
m_MaxWidth = DiceRange(0, 0, DEFAULT_MAX_WIDTH);
if (pDesc->FindAttribute(MIN_WIDTH_ATTRIB, &sRange))
{
if (error = m_MinWidth.LoadFromXML(sRange))
return error;
}
else
m_MinWidth = DiceRange(0, 0, DEFAULT_MIN_WIDTH);
// Colors
m_wPrimaryColor = ::LoadRGBColor(pDesc->GetAttribute(PRIMARY_COLOR_ATTRIB));
m_wSecondaryColor = ::LoadRGBColor(pDesc->GetAttribute(SECONDARY_COLOR_ATTRIB));
return NOERROR;
}
CSoundtrackManager::CSoundtrackManager (void) :
m_bEnabled(false),
m_iGameState(stateNone),
m_pNowPlaying(NULL),
m_LastPlayed(10),
m_bSystemTrackPlayed(false),
m_bStartCombatWhenUndocked(false)
// CSoundtrackManager constructor
{
// Hardcoded intro soundtrack
m_pIntroTrack = new CSoundType;
m_pIntroTrack->Init(0xFFFFFFFF, CONSTLIT("TranscendenceIntro.mp3"));
}
void CTranscendenceWnd::ReportCrashEvent (CString *retsMessage)
// ReportCrashEvent
//
// Include information about the given event
{
try
{
retsMessage->Append(g_pProgramEvent->DebugCrashInfo());
}
catch (...)
{
retsMessage->Append(strPatternSubst(CONSTLIT("error obtaining crash info from event: %x\r\n"), g_pProgramEvent));
}
}
ICCItem *CCodeChain::EvalLiteralStruct (CEvalContext *pCtx, ICCItem *pItem)
// EvalLiteralStruct
//
// Evalues the values in a structure and returns a structure
// (or an error).
{
int i;
CCSymbolTable *pTable = dynamic_cast<CCSymbolTable *>(pItem);
if (pTable == NULL)
return CreateError(CONSTLIT("Not a structure"), pItem);
ICCItem *pNew = CreateSymbolTable();
if (pNew->IsError())
return pNew;
CCSymbolTable *pNewTable = dynamic_cast<CCSymbolTable *>(pNew);
// Loop over all key/value pairs
for (i = 0; i < pTable->GetCount(); i++)
{
CString sKey = pTable->GetKey(i);
ICCItem *pValue = pTable->GetElement(i);
ICCItem *pNewKey = CreateString(sKey);
ICCItem *pNewValue = (pValue ? Eval(pCtx, pValue) : CreateNil());
ICCItem *pResult = pNewTable->AddEntry(this, pNewKey, pNewValue);
pNewKey->Discard(this);
pNewValue->Discard(this);
if (pResult->IsError())
{
pNewTable->Discard(this);
return pResult;
}
pResult->Discard(this);
}
// Done
return pNewTable;
}
CMultiverseModel::EOnlineStates CMultiverseModel::GetOnlineState (CString *retsUsername, CString *retsDesc) const
// GetOnlineState
//
// Returns the current online state (and optionally the username)
{
CSmartLock Lock(m_cs);
// Figure out our state
if (m_fDisabled)
{
if (retsUsername) *retsUsername = CONSTLIT("Offline");
#ifdef STEAM_BUILD
if (retsDesc) *retsDesc = CONSTLIT("Steam client is not running");
#else
if (retsDesc) *retsDesc = CONSTLIT("Multiverse disabled");
#endif
return stateDisabled;
}
else if (m_sUsername.IsBlank())
{
if (retsUsername) *retsUsername = CONSTLIT("Offline");
if (retsDesc) *retsDesc = CONSTLIT("Click to register a new account");
return stateNoUser;
}
else if (!m_fUserSignedIn)
{
if (retsUsername) *retsUsername = m_sUsername;
if (retsDesc) *retsDesc = CONSTLIT("Click to sign in");
return stateOffline;
}
else
{
if (retsUsername) *retsUsername = m_sUsername;
#ifdef STEAM_BUILD
if (retsDesc) *retsDesc = CONSTLIT("Connected to Steam");
#else
if (retsDesc) *retsDesc = CONSTLIT("Signed in to the Multiverse");
#endif
return stateOnline;
}
}
bool CAdventureDesc::IsValidStartingClass (CShipClass *pClass)
// IsValidStartingClass
//
// Return TRUE if this ship class is a valid starting class for this adventure.
{
if (m_fIncludeOldShipClasses && pClass->GetVersion() < 12)
{
if (pClass->HasAttribute(CONSTLIT("notInPartI")))
return false;
else
return true;
}
return (pClass->IsIncludedInAllAdventures() || pClass->MatchesCriteria(m_StartingShips));
}
ALERROR CSystemMap::ExecuteCreator (STopologyCreateCtx &Ctx, CTopology &Topology, CXMLElement *pCreator)
// ExecuteCreator
//
// Runs a specific creator
{
ALERROR error;
int i;
// If this is a root node tag then we add it and all its connections.
if (strEquals(pCreator->GetTag(), ROOT_NODE_TAG))
{
if (error = Topology.AddTopologyNode(Ctx, pCreator->GetAttribute(ID_ATTRIB)))
return error;
}
// Otherwise we process the creator element
else
{
for (i = 0; i < pCreator->GetContentElementCount(); i++)
{
CXMLElement *pDirective = pCreator->GetContentElement(i);
if (strEquals(pDirective->GetTag(), NODE_TAG))
{
if (error = Topology.AddTopologyNode(Ctx, pDirective->GetAttribute(ID_ATTRIB)))
return error;
}
else if (strEquals(pDirective->GetTag(), STARGATE_TAG) || strEquals(pDirective->GetTag(), STARGATES_TAG))
{
if (error = Topology.AddStargateFromXML(Ctx, pDirective))
return error;
}
else
{
Ctx.sError = strPatternSubst(CONSTLIT("Unknown TopologyCreator directive: %s."), pDirective->GetTag());
return ERR_FAIL;
}
}
}
return NOERROR;
}
ALERROR CExtension::ComposeLoadError (SDesignLoadCtx &Ctx, CString *retsError)
// ComposeLoadError
//
// Adds the filename to the load error.
{
if (retsError)
{
if (Ctx.sErrorFilespec)
*retsError = strPatternSubst(CONSTLIT("%s: %s"), Ctx.sErrorFilespec, Ctx.sError);
else
*retsError = Ctx.sError;
}
return ERR_FAIL;
}
void InitRequest (const CString &sHost, const CString &sMethod, const CString &sFunction, CHTTPMessage *retMessage)
// InitRequest
//
// Initializes a request
{
retMessage->InitRequest(sMethod, strPatternSubst(CONSTLIT("%s%s"), ROOT_URL_DEFAULT, sFunction));
retMessage->AddHeader(CONSTLIT("Host"), sHost);
retMessage->AddHeader(CONSTLIT("User-Agent"), CONSTLIT("TransData/1.0"));
retMessage->AddHeader(CONSTLIT("Accept-Language"), CONSTLIT("en-US"));
}
void CHexarcSession::InitRequest (const CString &sMethod, const CString &sFunction, CHTTPMessage *retMessage)
// InitRequest
//
// Initializes a request
{
retMessage->InitRequest(sMethod, strPatternSubst(CONSTLIT("%s%s"), m_sRootURL, sFunction));
retMessage->AddHeader(CONSTLIT("Host"), m_sHost);
retMessage->AddHeader(CONSTLIT("User-Agent"), CONSTLIT("TranscendenceClient/1.0"));
retMessage->AddHeader(CONSTLIT("Accept-Language"), CONSTLIT("en-US"));
}
ALERROR CEffectCreator::OnCreateFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc)
// OnCreateFromXML
//
// Load from XML. This is only called if we go through the EffectType path
// (as opposed to plain Effect).
{
ALERROR error;
// Basic info
m_sUNID = strFromInt(GetUNID(), FALSE);
m_dwSoundUNID = pDesc->GetAttributeInteger(SOUND_ATTRIB);
m_iSound = -1;
// Allow our subclass to initialize based on the effect
// (We know we have one because we couldn't have gotten this far
// without one. See CreateTypeFromXML.)
CXMLElement *pEffect = pDesc->GetContentElementByTag(EFFECT_TAG);
ASSERT(pEffect);
if (pEffect->GetContentElementCount() == 1)
error = OnEffectCreateFromXML(Ctx, pEffect->GetContentElement(0), m_sUNID);
else
error = OnEffectCreateFromXML(Ctx, pEffect, m_sUNID);
if (error)
return error;
// Load damage descriptors
CXMLElement *pDamageDesc = pDesc->GetContentElementByTag(DAMAGE_TAG);
if (pDamageDesc)
{
m_pDamage = new CWeaponFireDesc;
CString sUNID = strPatternSubst(CONSTLIT("%d/d"), GetUNID());
if (error = m_pDamage->InitFromXML(Ctx, pDamageDesc, sUNID, true))
return error;
}
return NOERROR;
}
ALERROR CS1Controller::LoadGuide (void)
// LoadGuide
//
// Loads the guide from disk
{
ALERROR error;
CString sError;
CFileReadBlock Input(CONSTLIT("Guide.xml"));
if (error = CXMLElement::ParseXML(&Input, &m_pGuide, &sError))
return error;
m_pPos = m_pGuide;
return NOERROR;
}
ALERROR CBeamEffectCreator::OnEffectCreateFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc, const CString &sUNID)
// OnEffectCreateFromXML
//
// Initialize type-specific data
{
m_iType = CBeamEffectCreator::ParseBeamType(pDesc->GetAttribute(BEAM_TYPE_ATTRIB));
if (m_iType == beamUnknown)
{
Ctx.sError = CONSTLIT("Invalid weapon beam type");
return ERR_FAIL;
}
// Load colors and intensity
m_wPrimaryColor = LoadRGBColor(pDesc->GetAttribute(PRIMARY_COLOR_ATTRIB));
m_wSecondaryColor = LoadRGBColor(pDesc->GetAttribute(SECONDARY_COLOR_ATTRIB));
m_iIntensity = pDesc->GetAttributeIntegerBounded(INTENSITY_ATTRIB, 0, -1, 1);
// For backward compatibility, some old types are converted
switch (m_iType)
{
case beamGreenParticle:
m_iType = beamParticle;
m_wPrimaryColor = CG16bitImage::RGBValue(95,241,42);
m_wSecondaryColor = CG16bitImage::RGBValue(95,241,42);
break;
case beamBlueParticle:
m_iType = beamParticle;
m_wPrimaryColor = CG16bitImage::RGBValue(255, 255, 255);
m_wSecondaryColor = CG16bitImage::RGBValue(64, 83, 255);
break;
case beamBlaster:
if (m_wPrimaryColor == 0) m_wPrimaryColor = CG16bitImage::RGBValue(255, 255, 0);
if (m_wSecondaryColor == 0) m_wSecondaryColor = CG16bitImage::RGBValue(255, 0, 0);
break;
}
return NOERROR;
}
ALERROR CEffectCreator::CreateSimpleFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc, const CString &sUNID, CEffectCreator **retpCreator)
// CreateSimpleFromXML
//
// Creates the creator from an XML element
{
ALERROR error;
CEffectCreator *pCreator;
// Create the effect based on the tag
if (error = CreateFromTag(pDesc->GetTag(), &pCreator))
{
Ctx.sError = strPatternSubst(CONSTLIT("Invalid painter tag: %s"), pDesc->GetTag());
return error;
}
if (pCreator == NULL)
return ERR_MEMORY;
pCreator->m_sUNID = sUNID;
pCreator->m_iInstance = instCreator;
// Load events
CXMLElement *pEventsDesc = pDesc->GetContentElementByTag(EVENTS_TAG);
if (pEventsDesc)
{
if (error = pCreator->m_Events.InitFromXML(Ctx, pEventsDesc))
return error;
}
// Type-specific creation
if (error = pCreator->OnEffectCreateFromXML(Ctx, pDesc, sUNID))
return error;
// Done
*retpCreator = pCreator;
return NOERROR;
}
void AddWord (TraverseCtx &Ctx, const CString &sWord)
{
// If this is a single character, then skip it
if (sWord.GetLength() == 1)
;
// Skip words that are all numbers and hex numbers
else if (isAllNumbers(sWord) || strFind(sWord, CONSTLIT("0x")) == 0)
;
// Otherwise, add it
else
{
Ctx.pWordList->AddEntry(strToLower(sWord), NULL);
}
}
void TransCompiler (CXMLElement *pCmdLine)
// TransCompiler
//
// Compile the Transcendence game and resource files
//
// <TransCompiler
// input="{input filespec}"
// output="{output filespec}"
// />
{
printf("TransCompiler v2.2\n");
printf("Copyright (c) 2003-2015 by Kronosaur Productions, LLC. All Rights Reserved.\n\n");
if (pCmdLine->GetAttributeBool(NOARGS) || pCmdLine->GetAttributeBool(SWITCH_HELP))
{
printf(" /input:{input filespec}\n");
printf(" /output:{output filespec}\n");
printf(" [/digest]\n");
printf(" [/dump]\n");
printf(" [/entities:{entity filespec}]\n");
printf("\n");
return;
}
// Figure out the folder for the input filespec. All filenames will
// be relative to this root.
CString sInputFilespec = pCmdLine->GetAttribute(ATTRIB_INPUT);
if (sInputFilespec.IsBlank())
sInputFilespec = CONSTLIT("Transcendence.xml");
// If we just want to dump an existing TDB then we do that
if (pCmdLine->GetAttributeBool(ATTRIB_DUMP) || strEquals(pathGetExtension(sInputFilespec), EXTENSION_TDB))
DumpTDB(sInputFilespec);
// Otherwise we are creating a new TDB
else
CreateTDB(sInputFilespec, pCmdLine);
}
