STDMETHODIMP CPigMissionParams::get_Experimental(VARIANT_BOOL* Experimental)
{
XLock lock(this);
USES_CONVERSION;
CLEAROUT(Experimental, VARBOOL(m_mp.bExperimental));
return S_OK;
}
STDMETHODIMP CPigMissionParams::get_Developments(VARIANT_BOOL* Developments)
{
XLock lock(this);
USES_CONVERSION;
CLEAROUT(Developments, VARBOOL(m_mp.bAllowDevelopments));
return S_OK;
}
STDMETHODIMP CAdminSessionHelper::get_IsAllSrvRunning(VARIANT_BOOL* pbIsRunning)
{
// Open the mutex using the global name first
HANDLE hMutex = ::OpenMutex(SYNCHRONIZE, false, szAllSrvRunningGlobal);
if (!hMutex)
hMutex = ::OpenMutex(SYNCHRONIZE, false, szAllSrvRunning);
bool bRunning = NULL != hMutex;
if (bRunning)
::CloseHandle(hMutex);
CLEAROUT(pbIsRunning, VARBOOL(bRunning));
return S_OK;
}
/*-------------------------------------------------------------------------
* get_GameParameters()
*-------------------------------------------------------------------------
*/
STDMETHODIMP CAdminGame::get_GameParameters(IAGCGameParameters** ppParams) // overrides IAGCGameImpl
{
// Perform default processing
RETURN_FAILED(IAGCGameImplBase::get_GameParameters(ppParams));
assert(*ppParams);
// Get the IGC pointer
ImissionIGC * pIGCMission = GetIGC();
assert(pIGCMission);
// Populate the team names
for (SideLinkIGC* psl = pIGCMission->GetSides()->first(); (psl != NULL); psl = psl->next())
{
IsideIGC* pside = psl->data();
if (pside)
{
CComBSTR bstrTemp(pside->GetName());
RETURN_FAILED((*ppParams)->put_TeamName(pside->GetObjectID(), bstrTemp));
}
}
// Get the CFSMission pointer
CFSMission* pFSMission = GetHostIGC();
// Set the StoryText property
CComBSTR bstrStoryText(pFSMission->GetStoryText());
RETURN_FAILED((*ppParams)->put_StoryText(bstrStoryText));
// Set the starting tech bits
if (pFSMission->m_pttbmAltered && pFSMission->m_pttbmNewSetting)
{
// Loop through the techbit masks for each team
for (int iSide = 0; iSide < c_cSidesMax; ++iSide)
{
// Loop through each techbit
for (short iBit = 0; iBit < c_ttbMax; ++iBit)
{
if (pFSMission->m_pttbmAltered[iSide].GetBit(iBit))
{
bool bBit = pFSMission->m_pttbmNewSetting[iSide].GetBit(iBit);
(*ppParams)->put_OverriddenTechBit(iSide, iBit, VARBOOL(bBit));
}
}
}
}
// Indicate success
return S_OK;
}
/***********************************************************************************************************************************
Build JSON output from options
***********************************************************************************************************************************/
String *
perlOptionJson(void)
{
FUNCTION_TEST_VOID();
String *result = NULL;
MEM_CONTEXT_TEMP_BEGIN()
{
KeyValue *configKv = kvNew();
for (ConfigOption optionId = 0; optionId < CFG_OPTION_TOTAL; optionId++)
{
// Skip if not valid
if (!cfgOptionValid(optionId))
continue;
Variant *optionVar = varNewKv(kvNew());
// Add valid
kvPut(varKv(optionVar), VARSTRDEF("valid"), BOOL_TRUE_VAR);
// Add source
const Variant *source = NULL;
switch (cfgOptionSource(optionId))
{
case cfgSourceParam:
{
source = VARSTRDEF("param");
break;
}
case cfgSourceConfig:
{
source = VARSTRDEF("config");
break;
}
case cfgSourceDefault:
{
source = VARSTRDEF("default");
break;
}
}
kvPut(varKv(optionVar), VARSTRDEF("source"), source);
// Add negate and reset
kvPut(varKv(optionVar), VARSTRDEF("negate"), VARBOOL(cfgOptionNegate(optionId)));
kvPut(varKv(optionVar), VARSTRDEF("reset"), VARBOOL(cfgOptionReset(optionId)));
// Add value if it is set
if (cfgOptionTest(optionId))
{
const Variant *valueVar = NULL;
switch (cfgDefOptionType(cfgOptionDefIdFromId(optionId)))
{
case cfgDefOptTypeBoolean:
case cfgDefOptTypeFloat:
case cfgDefOptTypeInteger:
case cfgDefOptTypePath:
case cfgDefOptTypeSize:
case cfgDefOptTypeString:
{
valueVar = cfgOption(optionId);
break;
}
case cfgDefOptTypeHash:
{
valueVar = varNewKv(kvNew());
const KeyValue *valueKv = cfgOptionKv(optionId);
const VariantList *keyList = kvKeyList(valueKv);
for (unsigned int listIdx = 0; listIdx < varLstSize(keyList); listIdx++)
kvPut(varKv(valueVar), varLstGet(keyList, listIdx), kvGet(valueKv, varLstGet(keyList, listIdx)));
break;
}
case cfgDefOptTypeList:
{
valueVar = varNewKv(kvNew());
const VariantList *valueList = cfgOptionLst(optionId);
for (unsigned int listIdx = 0; listIdx < varLstSize(valueList); listIdx++)
kvPut(varKv(valueVar), varLstGet(valueList, listIdx), BOOL_TRUE_VAR);
break;
}
}
kvPut(varKv(optionVar), VARSTRDEF("value"), valueVar);
}
kvPut(configKv, VARSTRZ(cfgOptionName(optionId)), optionVar);
}
memContextSwitch(MEM_CONTEXT_OLD());
result = jsonFromKv(configKv, 0);
memContextSwitch(MEM_CONTEXT_TEMP());
}
MEM_CONTEXT_TEMP_END();
FUNCTION_TEST_RETURN(result);
}
void CAGCEventLogger::LogEvent(IAGCEvent* pEvent, bool bSynchronous)
{
PRIVATE_ASSERTE(pEvent);
XLock lock(this);
// Determine if we can log to either event log type
bool bLogToNT = m_bLoggingToNTEnabled && !m_shEventLog.IsNull();
bool bLogToDB = m_bLoggingToDBEnabled && m_ds.m_spInit != NULL;
// Get the event ID
AGCEventID idEvent;
PRIVATE_VERIFYE(SUCCEEDED(pEvent->get_ID(&idEvent)));
// Determine if the event is enabled for each event log type
VARIANT_BOOL bEnabled;
if (bLogToNT && NULL != m_spRangesNT
&& SUCCEEDED(m_spRangesNT->get_IntersectsWithValue(idEvent, &bEnabled)))
bLogToNT = !!bEnabled;
if (bLogToDB && NULL != m_spRangesDB
&& SUCCEEDED(m_spRangesDB->get_IntersectsWithValue(idEvent, &bEnabled)))
bLogToDB = !!bEnabled;
// Unlock the CritSec
lock.Unlock();
// Do nothing if we're not logging this event anywhere
if (!bLogToNT && !bLogToDB)
return;
// Find the event definition
const CAGCEventDef::XEventDef* pEventDef = CAGCEventDef::find(idEvent);
PRIVATE_ASSERTE(pEventDef);
// Output the event to the debug monitor
#if 0 && defined(_DEBUG)
{
CComBSTR bstrDescription, bstrSubjectName;
PRIVATE_VERIFYE(SUCCEEDED(pEvent->get_Description(&bstrDescription)));
PRIVATE_VERIFYE(SUCCEEDED(pEvent->get_SubjectName (&bstrSubjectName)));
int cchDbg = bstrSubjectName.Length() + bstrDescription.Length() + 16;
_TRACE_BEGIN_SIZE(cchDbg)
if (bstrSubjectName.Length())
_TRACE_PART1("%ls:\n", (BSTR)bstrSubjectName);
if (bstrDescription.Length())
_TRACE_PART1("%ls\n" , (BSTR)bstrDescription);
_TRACE_END
}
#endif // defined(_DEBUG)
// Log the event to the NT Event Log, if specified
if (bLogToNT)
{
PRIVATE_ASSERTE(IsWinNT());
IAGCEventLoggerHookPtr spHook;
get_HookForNTLogging(&spHook);
if (NULL == spHook || S_FALSE == spHook->LogEvent(pEvent, VARBOOL(bSynchronous)))
{
XLock lockNT(this);
if (m_bLoggingToNTEnabled && !m_shEventLog.IsNull())
{
// Get the event severity
WORD wSeverity = pEventDef->m_wSeverity;
// Create the full event id (regarding the MC-generated id's)
UINT nBits;
switch (wSeverity)
{
case EVENTLOG_INFORMATION_TYPE: nBits = 0x01 << 30; break;
case EVENTLOG_WARNING_TYPE : nBits = 0x02 << 30; break;
case EVENTLOG_ERROR_TYPE : nBits = 0x03 << 30; break;
case EVENTLOG_SUCCESS : nBits = 0x00 << 30; break;
default : PRIVATE_ASSERTE(!"Bad severity code.");
}
DWORD dwEventID = nBits | idEvent;
// Get the event replacement parameters
CAGCEventDef::XParamStrings vecParamStrings;
PRIVATE_VERIFYE(SUCCEEDED(CAGCEventDef::GetEventParameters(pEvent,
vecParamStrings, pEventDef)));
// mdvalley: prevent crashes when no %Parameter% in strings.
// That took so long to figure out.
WORD NumStrings = vecParamStrings.size();
LPCWSTR* lpStrings = NULL;
if(NumStrings)
lpStrings = (LPCWSTR*)(&(*vecParamStrings.begin()));
// Report the event to the NT Event log
ReportEventW(m_shEventLog, wSeverity, 0, dwEventID, NULL,
vecParamStrings.size(), 0,
// VS.Net 2003 port
#if _MSC_VER >= 1310
lpStrings, NULL);
// (LPCWSTR*)(&(*vecParamStrings.begin())), NULL);
#else
(LPCWSTR*)(vecParamStrings.begin()), NULL);
#endif
// Free the replacement parameters BSTR's
for (CAGCEventDef::XParamStrings::iterator it = vecParamStrings.begin();
it != vecParamStrings.end(); ++it)
SysFreeString(*it);
}
}
