CEntity * CEntitiesFactory::SpawnEntity(const SEntityParams * params) {
CEntity * et = new CEntity(params->GetSide(), m_world);
if(params->GetType() == EET_SHIP) {
//hotfix: create controls and register to InputManager if not AI
AddComponents(et, params);
//if (!static_cast<const SShipParams *>(params)->IsAI()) {
InitEntityControls(et);
/* LOOKING INSIDE init_world.json and setting position/rotation */
CCompTransform * transform = new CCompTransform(et, 0, 0, 0);
et->AddComponent(transform); //will be set when init_world.json is parsed
FILE * wFile = fopen("data/conf/init_world.json", "rb");
char buffer[65536];
assert(wFile != nullptr && "CEntitiesFactory::SpawnEntity()");
rapidjson::FileReadStream is(wFile, buffer, sizeof(buffer));
rapidjson::Document cDoc;
cDoc.ParseStream<0, rapidjson::UTF8<>, rapidjson::FileReadStream>(is);
assert(!cDoc.HasParseError());
rapidjson::Value player;
if (et->GetSide() == EGS_PLAYER_1) {
player = cDoc["player1"];
} else if (et->GetSide() == EGS_PLAYER_2) {
player = cDoc["player2"];
}
for (rapidjson::Value::ConstMemberIterator itr = player.MemberBegin();
itr != player.MemberEnd(); ++itr) {
if (!strcmp(itr->name.GetString(), "position")) {
SSetPosMsg posMsg(itr->value["x"].GetFloat(), itr->value["y"].GetFloat());
et->ReceiveMessage(posMsg);
} else if (!strcmp(itr->name.GetString(), "rotation")) {
SSetRotMsg rotMsg(itr->value.GetFloat());
et->ReceiveMessage(rotMsg);
}
}
fclose(wFile);
} else if(params->GetType() == EET_PROJECTILE) {
AddComponents(et, params);
} else if (params->GetType() == EET_EXPLOSION) {
AddComponents(et, params);
} else if (params->GetType() == EET_DECOY) {
AddComponents(et, params);
} else if (params->GetType() == EET_BOT) {
AddComponents(et, params);
}
return et;
}
void HistoryMessage::applyEdition(const MTPDmessage &message) {
int keyboardTop = -1;
//if (!pendingResize()) {// #TODO edit bot message
// if (auto keyboard = inlineReplyKeyboard()) {
// int h = st::msgBotKbButton.margin + keyboard->naturalHeight();
// keyboardTop = _height - h + st::msgBotKbButton.margin - marginBottom();
// }
//}
if (message.has_edit_date()) {
_flags |= MTPDmessage::Flag::f_edit_date;
if (!Has<HistoryMessageEdited>()) {
AddComponents(HistoryMessageEdited::Bit());
}
auto edited = Get<HistoryMessageEdited>();
edited->date = message.vedit_date.v;
}
TextWithEntities textWithEntities = { qs(message.vmessage), EntitiesInText() };
if (message.has_entities()) {
textWithEntities.entities = TextUtilities::EntitiesFromMTP(message.ventities.v);
}
setReplyMarkup(message.has_reply_markup() ? (&message.vreply_markup) : nullptr);
refreshMedia(message.has_media() ? (&message.vmedia) : nullptr);
setViewsCount(message.has_views() ? message.vviews.v : -1);
setText(textWithEntities);
finishEdition(keyboardTop);
}
bool NFCClassModule::AddClassInclude(const char* pstrClassFilePath, NF_SHARE_PTR<NFIClass> pClass)
{
if (pClass->Find(pstrClassFilePath))
{
return false;
}
//////////////////////////////////////////////////////////////////////////
std::string strFile = pPluginManager->GetConfigPath() + pstrClassFilePath;
std::string strContent;
pPluginManager->GetFileContent(strFile, strContent);
rapidxml::xml_document<> xDoc;
xDoc.parse<0>((char*)strContent.c_str());
//////////////////////////////////////////////////////////////////////////
//support for unlimited layer class inherits
rapidxml::xml_node<>* root = xDoc.first_node();
rapidxml::xml_node<>* pRropertyRootNode = root->first_node("Propertys");
if (pRropertyRootNode)
{
AddPropertys(pRropertyRootNode, pClass);
}
//////////////////////////////////////////////////////////////////////////
//and record
rapidxml::xml_node<>* pRecordRootNode = root->first_node("Records");
if (pRecordRootNode)
{
AddRecords(pRecordRootNode, pClass);
}
rapidxml::xml_node<>* pComponentRootNode = root->first_node("Components");
if (pComponentRootNode)
{
AddComponents(pComponentRootNode, pClass);
}
//pClass->mvIncludeFile.push_back( pstrClassFilePath );
//and include file
rapidxml::xml_node<>* pIncludeRootNode = root->first_node("Includes");
if (pIncludeRootNode)
{
for (rapidxml::xml_node<>* includeNode = pIncludeRootNode->first_node(); includeNode; includeNode = includeNode->next_sibling())
{
const char* pstrIncludeFile = includeNode->first_attribute("Id")->value();
//std::vector<std::string>::iterator it = std::find( pClass->mvIncludeFile.begin(), pClass->mvIncludeFile..end(), pstrIncludeFile );
if (AddClassInclude(pstrIncludeFile, pClass))
{
pClass->Add(pstrIncludeFile);
}
}
}
return true;
}
i32 CGUIManager::Build(IInputLayout* pIL, xst_castring& strGroup)
{
CComponent::ComponentIterator Itr = m_pMainComp->GetChildIterator();
while( Itr.HasMoreElements() )
{
AddComponents( m_pRenderer, Itr.GetValue() );
Itr.MoveNext();
}
return m_pRenderer->BuildGUI( pIL, strGroup );
}
void Element::setDisplayDate(bool displayDate) {
const auto item = data();
if (displayDate && !Has<DateBadge>()) {
AddComponents(DateBadge::Bit());
Get<DateBadge>()->init(dateTime());
setPendingResize();
} else if (!displayDate && Has<DateBadge>()) {
RemoveComponents(DateBadge::Bit());
setPendingResize();
}
}
void HistoryItem::addLogEntryOriginal(
WebPageId localId,
const QString &label,
const TextWithEntities &content) {
Expects(isLogEntry());
AddComponents(HistoryMessageLogEntryOriginal::Bit());
Get<HistoryMessageLogEntryOriginal>()->page = _history->owner().webpage(
localId,
label,
content);
}
void RPG_DestructibleEntity::PostInitialize()
{
RPG_DamageableEntity::PostInitialize();
// Preload the mesh and effect to be used when this prop is destroyed.
RPG_VisionEffectHelper::LoadMesh(m_postDestructionMeshFilename);
AddComponents();
AddObstacle();
m_health = m_healthMax;
CreateEffect(DEFX_Ambient);
}
void Element::setUnreadBarCount(int count) {
const auto changed = AddComponents(UnreadBar::Bit());
const auto bar = Get<UnreadBar>();
if (bar->freezed) {
return;
}
bar->init(count);
if (changed) {
if (data()->mainView() == this) {
recountAttachToPreviousInBlocks();
}
history()->owner().requestViewResize(this);
} else {
history()->owner().requestViewRepaint(this);
}
}
void HistoryMessage::setReplyMarkup(const MTPReplyMarkup *markup) {
if (!markup) {
if (_flags & MTPDmessage::Flag::f_reply_markup) {
_flags &= ~MTPDmessage::Flag::f_reply_markup;
if (Has<HistoryMessageReplyMarkup>()) {
RemoveComponents(HistoryMessageReplyMarkup::Bit());
}
Auth().data().requestItemResize(this);
Notify::replyMarkupUpdated(this);
}
return;
}
// optimization: don't create markup component for the case
// MTPDreplyKeyboardHide with flags = 0, assume it has f_zero flag
if (markup->type() == mtpc_replyKeyboardHide && markup->c_replyKeyboardHide().vflags.v == 0) {
bool changed = false;
if (Has<HistoryMessageReplyMarkup>()) {
RemoveComponents(HistoryMessageReplyMarkup::Bit());
changed = true;
}
if (!(_flags & MTPDmessage::Flag::f_reply_markup)) {
_flags |= MTPDmessage::Flag::f_reply_markup;
changed = true;
}
if (changed) {
Auth().data().requestItemResize(this);
Notify::replyMarkupUpdated(this);
}
} else {
if (!(_flags & MTPDmessage::Flag::f_reply_markup)) {
_flags |= MTPDmessage::Flag::f_reply_markup;
}
if (!Has<HistoryMessageReplyMarkup>()) {
AddComponents(HistoryMessageReplyMarkup::Bit());
}
Get<HistoryMessageReplyMarkup>()->create(*markup);
Auth().data().requestItemResize(this);
Notify::replyMarkupUpdated(this);
}
}
void requester_freeze(int *num_vols, void *mountpoints, ErrorSet *errset)
{
COMPointer<IVssAsync> pAsync;
HANDLE volume;
HRESULT hr;
LONG ctx;
GUID guidSnapshotSet = GUID_NULL;
SECURITY_DESCRIPTOR sd;
SECURITY_ATTRIBUTES sa;
WCHAR short_volume_name[64], *display_name = short_volume_name;
DWORD wait_status;
int num_fixed_drives = 0, i;
int num_mount_points = 0;
if (vss_ctx.pVssbc) { /* already frozen */
*num_vols = 0;
return;
}
CoInitialize(NULL);
/* Allow unrestricted access to events */
InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = &sd;
sa.bInheritHandle = FALSE;
vss_ctx.hEventFrozen = CreateEvent(&sa, TRUE, FALSE, EVENT_NAME_FROZEN);
if (!vss_ctx.hEventFrozen) {
err_set(errset, GetLastError(), "failed to create event %s",
EVENT_NAME_FROZEN);
goto out;
}
vss_ctx.hEventThaw = CreateEvent(&sa, TRUE, FALSE, EVENT_NAME_THAW);
if (!vss_ctx.hEventThaw) {
err_set(errset, GetLastError(), "failed to create event %s",
EVENT_NAME_THAW);
goto out;
}
vss_ctx.hEventTimeout = CreateEvent(&sa, TRUE, FALSE, EVENT_NAME_TIMEOUT);
if (!vss_ctx.hEventTimeout) {
err_set(errset, GetLastError(), "failed to create event %s",
EVENT_NAME_TIMEOUT);
goto out;
}
assert(pCreateVssBackupComponents != NULL);
hr = pCreateVssBackupComponents(&vss_ctx.pVssbc);
if (FAILED(hr)) {
err_set(errset, hr, "failed to create VSS backup components");
goto out;
}
hr = vss_ctx.pVssbc->InitializeForBackup();
if (FAILED(hr)) {
err_set(errset, hr, "failed to initialize for backup");
goto out;
}
hr = vss_ctx.pVssbc->SetBackupState(true, true, VSS_BT_FULL, false);
if (FAILED(hr)) {
err_set(errset, hr, "failed to set backup state");
goto out;
}
/*
* Currently writable snapshots are not supported.
* To prevent the final commit (which requires to write to snapshots),
* ATTR_NO_AUTORECOVERY and ATTR_TRANSPORTABLE are specified here.
*/
ctx = VSS_CTX_APP_ROLLBACK | VSS_VOLSNAP_ATTR_TRANSPORTABLE |
VSS_VOLSNAP_ATTR_NO_AUTORECOVERY | VSS_VOLSNAP_ATTR_TXF_RECOVERY;
hr = vss_ctx.pVssbc->SetContext(ctx);
if (hr == (HRESULT)VSS_E_UNSUPPORTED_CONTEXT) {
/* Non-server version of Windows doesn't support ATTR_TRANSPORTABLE */
ctx &= ~VSS_VOLSNAP_ATTR_TRANSPORTABLE;
hr = vss_ctx.pVssbc->SetContext(ctx);
}
if (FAILED(hr)) {
err_set(errset, hr, "failed to set backup context");
goto out;
}
hr = vss_ctx.pVssbc->GatherWriterMetadata(pAsync.replace());
if (SUCCEEDED(hr)) {
hr = WaitForAsync(pAsync);
}
if (FAILED(hr)) {
err_set(errset, hr, "failed to gather writer metadata");
goto out;
}
AddComponents(errset);
if (err_is_set(errset)) {
goto out;
}
hr = vss_ctx.pVssbc->StartSnapshotSet(&guidSnapshotSet);
if (FAILED(hr)) {
err_set(errset, hr, "failed to start snapshot set");
goto out;
}
if (mountpoints) {
PWCHAR volume_name_wchar;
for (volList *list = (volList *)mountpoints; list; list = list->next) {
size_t len = strlen(list->value) + 1;
size_t converted = 0;
VSS_ID pid;
volume_name_wchar = new wchar_t[len];
mbstowcs_s(&converted, volume_name_wchar, len,
list->value, _TRUNCATE);
hr = vss_ctx.pVssbc->AddToSnapshotSet(volume_name_wchar,
g_gProviderId, &pid);
if (FAILED(hr)) {
err_set(errset, hr, "failed to add %S to snapshot set",
volume_name_wchar);
delete volume_name_wchar;
goto out;
}
num_mount_points++;
delete volume_name_wchar;
}
if (num_mount_points == 0) {
/* If there is no valid mount points, just exit. */
goto out;
}
}
if (!mountpoints) {
volume = FindFirstVolumeW(short_volume_name, sizeof(short_volume_name));
if (volume == INVALID_HANDLE_VALUE) {
err_set(errset, hr, "failed to find first volume");
goto out;
}
for (;;) {
if (GetDriveTypeW(short_volume_name) == DRIVE_FIXED) {
VSS_ID pid;
hr = vss_ctx.pVssbc->AddToSnapshotSet(short_volume_name,
g_gProviderId, &pid);
if (FAILED(hr)) {
WCHAR volume_path_name[PATH_MAX];
if (GetVolumePathNamesForVolumeNameW(
short_volume_name, volume_path_name,
sizeof(volume_path_name), NULL) &&
*volume_path_name) {
display_name = volume_path_name;
}
err_set(errset, hr, "failed to add %S to snapshot set",
display_name);
FindVolumeClose(volume);
goto out;
}
num_fixed_drives++;
}
if (!FindNextVolumeW(volume, short_volume_name,
sizeof(short_volume_name))) {
FindVolumeClose(volume);
break;
}
}
if (num_fixed_drives == 0) {
goto out; /* If there is no fixed drive, just exit. */
}
}
hr = vss_ctx.pVssbc->PrepareForBackup(pAsync.replace());
if (SUCCEEDED(hr)) {
hr = WaitForAsync(pAsync);
}
if (FAILED(hr)) {
err_set(errset, hr, "failed to prepare for backup");
goto out;
}
hr = vss_ctx.pVssbc->GatherWriterStatus(pAsync.replace());
if (SUCCEEDED(hr)) {
hr = WaitForAsync(pAsync);
}
if (FAILED(hr)) {
err_set(errset, hr, "failed to gather writer status");
goto out;
}
/*
* Start VSS quiescing operations.
* CQGAVssProvider::CommitSnapshots will kick vss_ctx.hEventFrozen
* after the applications and filesystems are frozen.
*/
hr = vss_ctx.pVssbc->DoSnapshotSet(&vss_ctx.pAsyncSnapshot);
if (FAILED(hr)) {
err_set(errset, hr, "failed to do snapshot set");
goto out;
}
/* Need to call QueryStatus several times to make VSS provider progress */
for (i = 0; i < VSS_TIMEOUT_FREEZE_MSEC/VSS_TIMEOUT_EVENT_MSEC; i++) {
HRESULT hr2 = vss_ctx.pAsyncSnapshot->QueryStatus(&hr, NULL);
if (FAILED(hr2)) {
err_set(errset, hr, "failed to do snapshot set");
goto out;
}
if (hr != VSS_S_ASYNC_PENDING) {
err_set(errset, E_FAIL,
"DoSnapshotSet exited without Frozen event");
goto out;
}
wait_status = WaitForSingleObject(vss_ctx.hEventFrozen,
VSS_TIMEOUT_EVENT_MSEC);
if (wait_status != WAIT_TIMEOUT) {
break;
}
}
if (wait_status == WAIT_TIMEOUT) {
err_set(errset, E_FAIL,
"timeout when try to receive Frozen event from VSS provider");
/* If we are here, VSS had timeout.
* Don't call AbortBackup, just return directly.
*/
goto out1;
}
if (wait_status != WAIT_OBJECT_0) {
err_set(errset, E_FAIL,
"couldn't receive Frozen event from VSS provider");
goto out;
}
if (mountpoints) {
*num_vols = vss_ctx.cFrozenVols = num_mount_points;
} else {
*num_vols = vss_ctx.cFrozenVols = num_fixed_drives;
}
return;
out:
if (vss_ctx.pVssbc) {
vss_ctx.pVssbc->AbortBackup();
}
out1:
requester_cleanup();
CoUninitialize();
}
bool NFCClassModule::AddClassInclude(const char* pstrClassFilePath, NF_SHARE_PTR<NFIClass> pClass)
{
if (pClass->Find(pstrClassFilePath))
{
return false;
}
//////////////////////////////////////////////////////////////////////////
rapidxml::xml_document<> xDoc;
char* pData = NULL;
int nDataSize = 0;
std::string strFile = pPluginManager->GetConfigPath() + pstrClassFilePath;
rapidxml::file<> fdoc(strFile.c_str());
nDataSize = fdoc.size();
pData = new char[nDataSize + 1];
strncpy(pData, fdoc.data(), nDataSize);
pData[nDataSize] = 0;
xDoc.parse<0>(pData);
//////////////////////////////////////////////////////////////////////////
//support for unlimited layer class inherits
rapidxml::xml_node<>* root = xDoc.first_node();
rapidxml::xml_node<>* pRropertyRootNode = root->first_node("Propertys");
if (pRropertyRootNode)
{
AddPropertys(pRropertyRootNode, pClass);
}
//////////////////////////////////////////////////////////////////////////
//and record
rapidxml::xml_node<>* pRecordRootNode = root->first_node("Records");
if (pRecordRootNode)
{
AddRecords(pRecordRootNode, pClass);
}
rapidxml::xml_node<>* pComponentRootNode = root->first_node("Components");
if (pComponentRootNode)
{
AddComponents(pComponentRootNode, pClass);
}
//pClass->mvIncludeFile.push_back( pstrClassFilePath );
//and include file
rapidxml::xml_node<>* pIncludeRootNode = root->first_node("Includes");
if (pIncludeRootNode)
{
for (rapidxml::xml_node<>* includeNode = pIncludeRootNode->first_node(); includeNode; includeNode = includeNode->next_sibling())
{
const char* pstrIncludeFile = includeNode->first_attribute("Id")->value();
//std::vector<std::string>::iterator it = std::find( pClass->mvIncludeFile.begin(), pClass->mvIncludeFile..end(), pstrIncludeFile );
if (AddClassInclude(pstrIncludeFile, pClass))
{
pClass->Add(pstrIncludeFile);
}
}
}
//////////////////////////////////////////////////////////////////////////
if (NULL != pData)
{
delete []pData;
}
//////////////////////////////////////////////////////////////////////////
return true;
}
