void SetRange(QCustomPlot& plot, int index, QVariantMap range, QCPAxis::AxisType type)
{
auto g = plot.graph(index);
auto it = range.find("lo");
if (it != range.end())
{
switch (type)
{
case QCPAxis::atLeft:
g->valueAxis()->setRangeLower(it->toReal());
break;
case QCPAxis::atBottom:
g->keyAxis()->setRangeLower(it->toReal());
break;
}
}
it = range.find("up");
if (it != range.end())
{
switch (type)
{
case QCPAxis::atLeft:
g->valueAxis()->setRangeUpper(it->toReal());
break;
case QCPAxis::atBottom:
g->keyAxis()->setRangeUpper(it->toReal());
break;
}
}
}
void ModemManager::ModemLocationInterface::propertiesChanged(const QString & interface, const QVariantMap & properties)
{
mmDebug() << interface << properties.keys();
if (interface == QString("org.freedesktop.ModemManager.Modem.Location")) {
QLatin1String capabilities("Capabilities");
QLatin1String enabled("Enabled");
QLatin1String signalsLocation("SignalsLocation");
QLatin1String location("Location");
QVariantMap::const_iterator it = properties.find(capabilities);
if ( it != properties.end()) {
emit capabilitiesChanged((ModemManager::ModemLocationInterface::Capability)it->toUInt());
}
it = properties.find(enabled);
if ( it != properties.end()) {
emit enabledChanged(it->toBool());
}
it = properties.find(signalsLocation);
if ( it != properties.end()) {
emit signalsLocationChanged(it->toBool());
}
it = properties.find(location);
if ( it != properties.end()) {
QVariant v = it.value();
LocationInformationMap map;
if (v.canConvert<LocationInformationMap>()) {
map = v.value<LocationInformationMap>();
} else {
mmDebug() << "Error converting LocationInformationMap property";
}
emit locationChanged(map);
}
}
}
QMap<QUrl,QUrl>* Fetcher::parseJson(QByteArray json)
{
QMap<QUrl,QUrl>* urls = new QMap<QUrl,QUrl>();
QJsonDocument jsonDoc = QJsonDocument::fromJson(json);
QVariantMap result = jsonDoc.toVariant().toMap();
QVariantMap responseData = (*result.find("responseData")).toMap();
QVariantList resultList = (*responseData.find("results")).toList();
QVariantMap tmp;
QVariant tbUrl,imgUrl;
QString tbUrlString,imgUrlString;
QVariantList::iterator it;
for(it = resultList.begin() ; it != resultList.end() ; ++it)
{
tmp = (*it).toMap();
tbUrl = (*tmp.find("tbUrl"));
imgUrl = (*tmp.find("unescapedUrl"));
tbUrlString = tbUrl.toString();
imgUrlString = imgUrl.toString();
urls->insert(QUrl(imgUrlString),QUrl(tbUrlString));
}
return urls;
}
void YandexNarodAuthorizator::onRequestFinished(QNetworkReply *reply)
{
reply->deleteLater();
if (reply != m_reply.data())
return;
QVariantMap data = Json::parse(reply->readAll()).toMap();
QVariantMap::Iterator error = data.find(QLatin1String("error"));
if (error != data.end() || reply->error() != QNetworkReply::NoError) {
QString errorStr = error.value().toString();
m_stage = Need;
if (errorStr == QLatin1String("unsupported_grant_type"))
emit result(Error, tr("Unsupported grant type. Inform developers."));
else if (errorStr == QLatin1String("invalid_request"))
emit result(Error, tr("Invalid request. Inform developers."));
else
emit result(Error, tr("Invalid login or/and password"));
return;
}
QString accessToken = data.value(QLatin1String("access_token")).toString();
QDateTime expiresAt;
QVariantMap::Iterator expiresIn = data.find(QLatin1String("expires_in"));
if (expiresIn != data.end()) {
expiresAt = QDateTime::currentDateTime();
expiresAt.addSecs(expiresIn.value().toInt());
}
debug() << accessToken << data;
m_token = accessToken;
m_stage = Already;
emit result(Success);
emit needSaveCookies();
}
void Globalization::dateToString(int scId, int ecId, const QVariantMap &options) {
time_t time = options.find("time_t")->toLongLong() / 1000;
Globalization::Format formatLength = static_cast<Globalization::Format>(options.find("formatLength")->toInt());
Globalization::Selector selector = static_cast<Globalization::Selector>(options.find("selector")->toInt());
QLocale::FormatType format = translateFormat(formatLength);
if (time < 0) {
this->callback(ecId, QString("new GlobalizationError(%1, 'unsupported operation');").arg(Globalization::FORMATTING_ERROR));
return;
}
QLocale locale;
QString res;
QDateTime dateTime = QDateTime::fromTime_t((uint)time);
switch (selector) {
case SELECTOR_ALL:
res = locale.toString(dateTime,format);
break;
case SELECTOR_TIME:
res = locale.toString(dateTime.time(), format);
break;
case SELECTOR_DATE:
res = locale.toString(dateTime.date(), format);
break;
}
QVariantMap obj;
obj.insert("value", res);
this->cb(scId, obj);
}
void RemoteActivatable::propertiesChanged(const QVariantMap &changedProperties)
{
Q_D(RemoteActivatable);
QStringList propKeys = changedProperties.keys();
QLatin1String deviceUniKey("deviceUni"),
activatableTypeKey("activatableType"),
sharedKey("shared");
QVariantMap::const_iterator it = changedProperties.find(deviceUniKey);
if (it != changedProperties.end())
{
d->deviceUni = it->toString();
propKeys.removeOne(deviceUniKey);
}
it = changedProperties.find(activatableTypeKey);
if (it != changedProperties.end())
{
d->activatableType = (Knm::Activatable::ActivatableType)it->toUInt();
propKeys.removeOne(activatableTypeKey);
}
it = changedProperties.find(sharedKey);
if (it != changedProperties.end())
{
d->shared = it->toBool();
propKeys.removeOne(sharedKey);
}
/*if (propKeys.count()) {
qDebug() << "Unhandled properties: " << propKeys;
}*/
}
void Globalization::stringToDate(int scId, int ecId, const QVariantMap &options) {
QString dateString = options.find("dateString")->toString();
Globalization::Format formatLength = static_cast<Globalization::Format>(options.find("formatLength")->toInt());
Globalization::Selector selector = static_cast<Globalization::Selector>(options.find("selector")->toInt());
QLocale::FormatType format = translateFormat(formatLength);
QLocale locale;
bool valid(true);
int year(0), month(0), day(0), hour(0), minute(0), second(0), millisecond(0);
switch (selector) {
case SELECTOR_ALL:
{
QDateTime dateTime = locale.toDateTime(dateString, format);
valid = dateTime.isValid();
QTime time = dateTime.time();
hour = time.hour(); minute = time.minute(); second = time.second(); millisecond = time.msec();
QDate date = dateTime.date();
year = date.year(); month = date.month(); day = date.day();
}
break;
case SELECTOR_TIME:
{
QTime time = locale.toTime(dateString, format);
valid = time.isValid();
hour = time.hour(); minute = time.minute(); second = time.second(); millisecond = time.msec();
}
break;
case SELECTOR_DATE:
{
QDate date = locale.toDate(dateString, format);
valid = date.isValid();
year = date.year(); month = date.month(); day = date.day();
}
break;
}
if ((format == QLocale::NarrowFormat || format == QLocale::ShortFormat) && year < 2000 && year > 1900) {
year += 100;
}
if (!valid) {
this->callback(ecId, QString("new GlobalizationError(%1, 'parsing error')").arg(Globalization::PARSING_ERROR));
} else {
QVariantMap obj;
obj.insert("year", year);
obj.insert("month", month - 1);
obj.insert("day", day);
obj.insert("hour", hour);
obj.insert("minute", minute);
obj.insert("second", second);
obj.insert("millisecond", millisecond);
this->cb(scId, obj);
}
}
void KonvergoWindow::updateMainSectionSettings(const QVariantMap& values)
{
// update mouse visibility if needed
if (values.find("disablemouse") != values.end())
{
SystemComponent::Get().setCursorVisibility(!SettingsComponent::Get().value(SETTINGS_SECTION_MAIN, "disablemouse").toBool());
}
if (values.find("fullscreen") == values.end())
return;
updateFullscreenState();
}
void DecorationBridge::findTheme(const QVariantMap &map)
{
auto it = map.find(QStringLiteral("themes"));
if (it == map.end()) {
return;
}
if (!it.value().toBool()) {
return;
}
it = map.find(QStringLiteral("defaultTheme"));
m_defaultTheme = it != map.end() ? it.value().toString() : QString();
m_theme = readTheme();
}
void QCouch::checkErrors(QVariant var){
QVariantMap map = var.toMap();
if ( map.find("error") != map.end() ) {
throw CouchException(map["reason"].toString());
}
}
QVariant & value_unsafe(const QStringList & keys, QVariantMap & context){
QVariantMap* map = &context;
int i = 0;
while(i < keys.size()) {
const QString & key = keys.at(i++);
QVariantMap::iterator it = map->find(key);
if(it == map->constEnd())
return nullVariant;
QVariant & value = *it;
if(i >= keys.size())
return value;
if(value.type() == QVariant::Map)
map = &asMap(value);
else if(i == keys.size() -1 && value.type() == QVariant::List) {
const QString & idxStr = keys.at(i);
bool ok;
int idx = idxStr.toInt(&ok);
if(ok) {
QVariantList & lst = asList(value);
if(idx < lst.size())
return lst[idx];
}
}
else
return nullVariant;
}
return nullVariant;
}
void MprisPlayer::onPropertiesChanged(const QDBusMessage &msg)
{
QDBusArgument arg = msg.arguments().at(1).value<QDBusArgument>();
QVariantMap map = qdbus_cast<QVariantMap>(arg);
QVariantMap::const_iterator it = map.find(QLatin1String("Metadata"));
if (it != map.end()) {
arg = it.value().value<QDBusArgument>();
onTrackChanged(qdbus_cast<QVariantMap>(arg));
}
it = map.find(QLatin1String("PlaybackStatus"));
if (it != map.end()) {
DBusMprisPlayerStatus status;
status.Play = it.value().toString() == QLatin1String("Playing") ? 0 : 1;
onStatusChanged(status);
}
}
static void testFlashValidatorsDriver(const QVariantMap ¶ms, const QVariantMap &validators, Context::Errors &errors)
{
QVariantMap::const_iterator ii, endii;
QVariantMap::const_iterator vv;
endii = params.end();
for (ii = params.begin(); ii != endii; ++ii) {
// check if there is a validator for this param
vv = validators.find(ii.key());
if (vv == validators.end())
continue;
// if its a map, we recurse
if (vv->type() == QVariant::Map)
testFlashValidatorsDriver(asVariantMap(*ii), asVariantMap(*vv), errors);
else {
// its not a map, execute the validator
ValidationExpr validexpr = ValidationExpr::fromVariant(*vv);
QStringList errorslist;
validexpr.test(*ii, &errorslist);
if (!errorslist.isEmpty())
errors[ii.key()] = errorslist;
}
}
}
static QString themeListKeyword(const QVariantMap &decoSettingsMap)
{
auto it = decoSettingsMap.find(QStringLiteral("themeListKeyword"));
if (it == decoSettingsMap.end()) {
return QString();
}
return it.value().toString();
}
static bool isConfigureable(const QVariantMap &decoSettingsMap)
{
auto it = decoSettingsMap.find(QStringLiteral("kcmodule"));
if (it == decoSettingsMap.end()) {
return false;
}
return it.value().toBool();
}
static QString findKNewStuff(const QVariantMap &decoSettingsMap)
{
auto it = decoSettingsMap.find(QStringLiteral("KNewStuff"));
if (it == decoSettingsMap.end()) {
return QString();
}
return it.value().toString();
}
void Globalization::isDayLightSavingsTime(int scId, int ecId, const QVariantMap &options) {
time_t time = options.find("time_t")->toLongLong() / 1000;
const tm *desc = std::localtime(&time);
if (desc->tm_isdst < 0) {
this->callback(ecId, QString("new GlobalizationError(%1, 'information is not available');").arg(Globalization::UNKNOWN_ERROR));
return;
}
this->callback(scId, QString("{dst:%1}").arg(desc->tm_isdst > 0 ? "true" : "false"));
}
void MMModemGsmNetworkInterface::propertiesChanged(const QString & interface, const QVariantMap & properties)
{
kDebug(1441) << interface << properties.keys();
if (interface == QString("org.freedesktop.ModemManager.Modem.Gsm.Network")) {
QLatin1String allowedMode("AllowedMode");
QLatin1String accessTechnology("AccessTechnology");
QVariantMap::const_iterator it = properties.find(allowedMode);
if ( it != properties.end()) {
emit allowedModeChanged((Solid::Control::ModemInterface::AllowedMode) it->toInt());
}
it = properties.find(accessTechnology);
if ( it != properties.end()) {
emit accessTechnologyChanged((Solid::Control::ModemInterface::AccessTechnology) it->toInt());
}
}
}
void Namespace::setProperties(QVariantMap const &src)
{
for (auto kv : setters_for_props_) {
auto name = kv.first;
auto psrc = src.find(name);
if (psrc != src.end()) {
auto set = kv.second;
set(valueEncode(psrc.value()).toStdString());
}
}
}
void QCouch::createDatabase(QString name){
const QByteArray emptyBytes;
QNetworkReply *reply = doPut("/" + name, emptyBytes);
QVariant var = parser.parse(reply->readAll());
QVariantMap map = var.toMap();
if ( map.find("error") != map.end() ) {
throw CouchException(map["reason"].toString());
}
}
//==============================================================================
void GameServer::handleFEMPRequest(const QVariantMap& request, QVariantMap& response)
{
response["action"] = request["action"];
auto actionIt = request.find("action");
if (actionIt == request.end())
{
WriteResult_(response, EFEMPResult::BAD_ACTION);
return;
}
QString action = actionIt.value().toString();
//qDebug() << "FEMP action: " << action;
auto handlerIt = requestHandlers_.find(action);
if (handlerIt == requestHandlers_.end())
{
WriteResult_(response, EFEMPResult::BAD_ACTION);
return;
}
// TODO: extract into unordered_map
if (sidCheckExceptions_.count(action.toStdString()) == 0)
{
if (request.find("sid") == request.end()
|| sidToPlayer_.find(request["sid"].toByteArray()) == sidToPlayer_.end())
{
WriteResult_(response, EFEMPResult::BAD_SID);
return;
}
}
auto handler = handlerIt.value();
(this->*handler)(request, response);
if (response.find("result") == response.end())
{
WriteResult_(response, EFEMPResult::OK);
}
}
//==============================================================================
void GameServer::HandleDestroyItem_(const QVariantMap& request, QVariantMap& response)
{
#define BAD_ID(COND)\
if (COND)\
{\
WriteResult_(response, EFEMPResult::BAD_ID);\
return;\
}\
BAD_ID(request.find("id") == request.end());
int id = request["id"].toInt();
BAD_ID(!id);
Player* p = sidToPlayer_[request["sid"].toByteArray()];
if (p->DropItemFromSlot(id))
{
//destroy item from slot
WriteResult_(response, EFEMPResult::OK);
return;
}
if (p->GetItemId(id))
{
//destroy item from inventory
for (auto& item : p->items_)
{
if (item->GetId() == id)
{
p->items_.erase(std::remove(p->items_.begin(), p->items_.end(), item), p->items_.end());
idToActor_.erase(id);
break;
}
}
}
else
{
//item is on the ground
Item* item = dynamic_cast<Item*>(idToActor_[id]);
BAD_ID(!item || !item->GetOnTheGround());
Vector2 player_pos = p->GetPosition();
Vector2 item_pos = item->GetPosition();
float distance2 = Sqr(player_pos.x - item_pos.x)
+ Sqr(player_pos.y - item_pos.y);
BAD_ID(distance2 > Sqr(pickUpRadius_))
KillActor_(item);
}
// TODO: implement
#undef BAD_ID
}
bool JsonRpcServer::convertArgs(const QMetaMethod& meta_method,
const QVariantMap& args,
QVariantList& converted_args)
{
QList<QByteArray> param_types = meta_method.parameterTypes();
if (args.size() != param_types.size()) {
logError(QString("wrong number of arguments to method %1 -- "
"expected %2 arguments, but got %3")
.arg(QString(meta_method.methodSignature()))
.arg(meta_method.parameterCount())
.arg(args.size()));
return false;
}
for (int i = 0; i < param_types.size(); i++) {
QByteArray param_name = meta_method.parameterNames().at(i);
if (args.find(param_name) == args.end()) {
// no arg with param name found
return false;
}
const QVariant& arg = args.value(param_name);
if (!arg.isValid()) {
logError(QString("argument %1 of %2 to method %3 is invalid")
.arg(i + 1)
.arg(param_types.size())
.arg(QString(meta_method.methodSignature())));
return false;
}
QByteArray arg_type_name = arg.typeName();
QByteArray param_type_name = param_types.at(i);
QVariant::Type param_type = QVariant::nameToType(param_type_name);
QVariant copy = QVariant(arg);
if (copy.type() != param_type) {
if (copy.canConvert(param_type)) {
if (!copy.convert(param_type)) {
// qDebug() << "cannot convert" << arg_type_name
// << "to" << param_type_name;
return false;
}
}
}
converted_args << copy;
}
return true;
}
void parseToProperties(const QByteArray &json, QObject *obj)
{
QVariantMap map = parse(json).toMap();
const QMetaObject *meta = obj->metaObject();
for (int i = 0, size = meta->propertyCount(); i < size; i++) {
QMetaProperty prop = meta->property(i);
QVariantMap::iterator it = map.find(prop.name());
if (it != map.end()) {
QVariant var = it.value();
if (var.canConvert(prop.type())) {
prop.write(obj, var);
}
}
}
}
void ReplicaSetSettings::fromVariant(const QVariantMap &map)
{
setSetName(map.value("setName").toString().toStdString());
// Extract and set replica members
std::vector<std::string> vec;
auto itr = map.begin();
int idx = 0;
do
{
itr = map.find(QString::number(idx));
if (map.end() == itr) break;
vec.push_back(itr->toString().toStdString());
++idx;
} while (map.end() != itr);
setMembers(vec);
// Extract and set read reference
setReadPreference(static_cast<ReadPreference>(map.value("readPreference").toInt()));
}
void DataModelManager::appendItem(QVariantMap arrValues)
{
if(m_bDataClassSet)
{
QObject *pObject = m_oDataClassMetaObject.newInstance();
if(pObject != NULL)
{
const QStringList c_arrProperties = DataObjectProperties();
foreach (const QString strProperty, c_arrProperties)
{
if(arrValues.contains(strProperty)) // je-li hodnota nastavena, nastaví se
{
pObject->setProperty(strProperty.toStdString().c_str(), arrValues.find(strProperty).value());
}
}
m_arrData.append(pObject);
emit dataModelChanged();
}
}
}
void RemoteInterfaceConnection::icPropertiesChanged(const QVariantMap &changedProperties)
{
Q_D(RemoteInterfaceConnection);
QStringList propKeys = changedProperties.keys();
QLatin1String connectionTypeKey("connectionType"),
uuidKey("uuid"),
nameKey("name"),
iconNameKey("iconName"),
activationStateKey("activationState"),
hasDefaultRouteKey("hasDefaultRoute");
QVariantMap::const_iterator it = changedProperties.find(connectionTypeKey);
if (it != changedProperties.end()) {
d->connectionType = (Knm::Connection::Type)it->toUInt();
propKeys.removeOne(connectionTypeKey);
}
it = changedProperties.find(uuidKey);
if (it != changedProperties.end()) {
d->uuid = it->toString();
propKeys.removeOne(uuidKey);
}
it = changedProperties.find(nameKey);
if (it != changedProperties.end()) {
d->name = it->toString();
propKeys.removeOne(nameKey);
}
it = changedProperties.find(iconNameKey);
if (it != changedProperties.end()) {
d->iconName = it->toString();
propKeys.removeOne(iconNameKey);
}
it = changedProperties.find(activationStateKey);
if (it != changedProperties.end()) {
d->oldActivationState = d->activationState;
d->activationState = (Knm::InterfaceConnection::ActivationState)it->toUInt();
emit activationStateChanged(d->oldActivationState, d->activationState);
propKeys.removeOne(activationStateKey);
}
it = changedProperties.find(hasDefaultRouteKey);
if (it != changedProperties.end()) {
d->hasDefaultRoute = it->toBool();
emit hasDefaultRouteChanged(d->hasDefaultRoute);
propKeys.removeOne(hasDefaultRouteKey);
}
/*if (propKeys.count()) {
kDebug() << "Unhandled properties: " << propKeys;
}*/
emit changed();
}
//==============================================================================
void GameServer::HandleEquip_(const QVariantMap& request, QVariantMap& response)
{
#define BAD_ID(COND)\
if (COND)\
{\
WriteResult_(response, EFEMPResult::BAD_ID);\
return;\
}\
BAD_ID(request.find("id") == request.end());
BAD_ID(!request["id"].toInt());
QString slot = request["slot"].toString();
if (SlotToString.find(slot) == SlotToString.end())
{
WriteResult_(response, EFEMPResult::BAD_SLOT);
return;
}
int id = request["id"].toInt();
auto sid = request["sid"].toByteArray();
Player* p = sidToPlayer_[sid];
BAD_ID((idToActor_.find(id) == idToActor_.end()) && !p->GetItemId(id));
if (p->GetItemId(id))
{
//equip item from inventory
for (auto& item: p->items_)
{
if (item->GetId() == id)
{
Item* i = p->GetSlot(SlotToString[slot]);
if (i)
{
p->items_.push_back(i);
}
if (!p->SetSlot(SlotToString[slot], item))
{
WriteResult_(response, EFEMPResult::BAD_SLOT);
return;
}
p->SetStat(true, item);
p->items_.erase(std::remove(p->items_.begin(), p->items_.end(), item), p->items_.end());
WriteResult_(response, EFEMPResult::OK);
return;
}
}
BAD_ID(true);
}
else
{
//item is on the ground
Item* item = dynamic_cast<Item*>(idToActor_[id]);
BAD_ID(!item);
Vector2 player_pos = p->GetPosition();
Vector2 item_pos = item->GetPosition();
float distance2 = Sqr(player_pos.x - item_pos.x) + Sqr(player_pos.y - item_pos.y);
BAD_ID(distance2 > Sqr(pickUpRadius_))
if (!p->SetSlot(SlotToString[slot], item))
{
WriteResult_(response, EFEMPResult::BAD_SLOT);
return;
}
p->SetStat(true, item);
//KillActor_(item); ???
idToActor_.erase(item->GetId());
actors_.erase(std::remove(actors_.begin(), actors_.end(), item), actors_.end());
}
#undef BAD_ID
}
//==============================================================================
void GameServer::HandleUse_(const QVariantMap& request, QVariantMap& response)
{
auto sid = request["sid"].toByteArray();
Player* p = sidToPlayer_[sid];
if (!request["id"].toInt())
{
WriteResult_(response, EFEMPResult::BAD_ID);
return;
}
int id = request["id"].toInt();
Item* item = dynamic_cast<Item*>(idToActor_[request["id"].toInt()]);
if (item)
{
if (request.find("x") == request.end() && request.find("y") == request.end())
{
if (item->GetSubtype() != "consumable")
{
WriteResult_(response, EFEMPResult::BAD_ID);
return;
}
else
{
p->SetHealth(p->GetHealth() + item->bonuses[EStatConst::HP]["value"].toFloat());
WriteResult_(response, EFEMPResult::OK);
return;
}
}
if ((item != p->GetSlot(left_hand)
|| item != p->GetSlot(right_hand))
&& (p->GetSlot(left_hand) != 0
|| p->GetSlot(right_hand)!= 0 )
&& id != FistId_)
{
WriteResult_(response, EFEMPResult::BAD_SLOT);
return;
}
WriteResult_ (response, EFEMPResult::OK);
return;
}
if (!request["x"].toFloat() || !request["y"].toFloat())
{
WriteResult_(response, EFEMPResult::BAD_PLACING);
return;
}
for (Actor* actor : actors_)
{
if (actor->GetType() != EActorType::ITEM
&& actor->GetType() != EActorType::PROJECTILE)
{
Creature* target = static_cast<Creature*>(actor);
if ((p->GetId() != target->GetId())
&& (target->GetHealth() > 0))
{
Vector2 player_pos = p->GetPosition();
Vector2 target_pos = target->GetPosition();
float distance2 = Sqr(player_pos.x - target_pos.x)
+ Sqr(player_pos.y - target_pos.y);
if (distance2 <= Sqr(pickUpRadius_))
{
QVariantMap a = p->atack(target, id);
events_ << a;
if (target->GetHealth() <= 0)
{
GetItems(target);
p->SetExperience(p->GetExperience () + 300);
int lev = p->GetLevel();
p->SetLevel (p->GetExperience() / 1000);
if (lev < p->GetLevel())
{
p->AddStat ();
p->UpdateStat();
}
}
else
{
a = target->atack(p);
events_ << a;
}
WriteResult_(response, EFEMPResult::OK);
return;
}
}
}
}
}
void PrefabSystem::updatePrefab(const QString& path, const QVariantMap& newcomponents, bool updateInstances)
{
// fetch prefab by path
Prefab* prefab;
{
auto i = _prefabs.find(path);
if(i == _prefabs.end())
{
return;
}
prefab = i.value().data();
}
for(auto k: newcomponents.keys())
{
qDebug() << "Receeived: " << k;
}
if(updateInstances)
{
// update existing components in prefab and delete components no longer in prefab
for(auto j = prefab->components().begin(); j != prefab->components().end(); ++j)
{
EntitySystem* es = entityManager()->system(j.key());
Q_ASSERT(es);
if(!es) continue;
// component is in prefab but not in components map. Delete it from prefab instances.
if(newcomponents.find(j.key()) == newcomponents.end())
{
qDebug() << "Removing from prefab instances:" << j.key();
// find all prefab instances and destroy the component
for(auto k = this->begin(); k != this->end(); ++k)
{
PrefabInstance* pi = static_cast<PrefabInstance*>(k->second);
if(pi->prefab() == prefab)
{
es->destroyComponent(k->first);
}
}
}
else
{
// component exists in component map and in prefab. Update prefab.
QVariantMap newvals = newcomponents[j.key()].toMap();
// find all prefab instances and update the components
for(auto k = this->begin(); k != this->end(); ++k)
{
PrefabInstance* pi = static_cast<PrefabInstance*>(k->second);
if(pi->prefab() == prefab)
{
QVariantMap data = es->toVariantMap(k->first);
for(auto i = newvals.begin(); i != newvals.end(); ++i)
{
data[i.key()] = i.value();
}
auto i = data.begin();
while(i != data.end())
{
if(prefab->parameters().contains(i.key()) || i.key() == "objectName")
{
i = data.erase(i);
}
else
{
++i;
}
}
es->fromVariantMap(k->first, data);
}
}
}
}
// now handle the components that did not exist in prefab yet
for(auto i = newcomponents.begin(); i != newcomponents.end(); ++i)
{
QString key = i.key();
if(prefab->components().find(key) == prefab->components().end())
{
EntitySystem* es = entityManager()->system(key);
Q_ASSERT(es);
if(!es) continue;
for(auto k = this->begin(); k != this->end(); ++k)
{
PrefabInstance* pi = static_cast<PrefabInstance*>(k->second);
if(pi->prefab() == prefab)
{
es->createComponent(k->first, i.value().toMap());
}
}
}
}
}
// finally update prefab in prefab store
prefab->setComponents(newcomponents);
emit prefabUpdated(path);
}
