std::map<int, PluginSpec> ModulesPluginDatabase::lookupAllProvidesWithStatus (std::string const & which) const { std::string errors; std::vector<std::string> allPlugins = listAllPlugins (); std::map<int, PluginSpec> foundPlugins; for (auto const & plugin : allPlugins) { // TODO: make sure (non)-equal plugins (i.e. with same/different contract) are handled correctly try { PluginSpec spec = PluginSpec ( plugin, KeySet (5, *Key ("system/module", KEY_VALUE, "this plugin was loaded without a config", KEY_END), KS_END)); // lets see if there is a plugin named after the required provider if (plugin == which) { int s = calculateStatus (lookupInfo (spec, "status")); foundPlugins.insert (std::make_pair (s, PluginSpec (plugin))); continue; // we are done with this plugin } // TODO: support for generic plugins with config std::istringstream ss (lookupInfo (spec, "provides")); std::string provide; while (ss >> provide) { if (provide == which) { int s = calculateStatus (lookupInfo (spec, "status")); foundPlugins.insert (std::make_pair (s, PluginSpec (plugin))); } } } catch (std::exception const & e) { errors += e.what (); errors += ","; } // assume not loaded } if (foundPlugins.empty ()) { if (!errors.empty ()) throw NoPlugin ("No plugin that provides " + which + " could be found, got errors: " + errors); else throw NoPlugin ("No plugin that provides " + which + " could be found"); } return foundPlugins; }
PluginSpec ModulesPluginDatabase::lookupProvides (std::string const & which) const { // check if plugin itself exists: if (status (PluginSpec (which)) == real) { return PluginSpec (which); } std::string errors; std::vector<std::string> allPlugins = listAllPlugins (); std::map<int, PluginSpec> foundPlugins; for (auto const & plugin : allPlugins) { // TODO: make sure (non)-equal plugins (i.e. with same/different contract) are handled correctly try { // TODO: support for generic plugins with config std::istringstream ss ( lookupInfo (PluginSpec (plugin, KeySet (5, *Key ("system/module", KEY_VALUE, "this plugin was loaded without a config", KEY_END), KS_END)), "provides")); std::string provide; while (ss >> provide) { if (provide == which) { int s = calculateStatus (lookupInfo ( PluginSpec (plugin, KeySet (5, *Key ("system/module", KEY_VALUE, "this plugin was loaded without a config", KEY_END), KS_END)), "status")); foundPlugins.insert (std::make_pair (s, PluginSpec (plugin))); } } } catch (std::exception const & e) { errors += e.what (); errors += ","; } // assume not loaded } if (foundPlugins.empty ()) { if (!errors.empty ()) throw NoPlugin ("No plugin that provides " + which + " could be found, got errors: " + errors); else throw NoPlugin ("No plugin that provides " + which + " could be found"); } // the largest element of the map contains the best-suited plugin: return foundPlugins.rbegin ()->second; }
PluginSpec ModulesPluginDatabase::lookupMetadata (std::string const & which) const { std::vector<std::string> allPlugins = listAllPlugins (); std::map<int, PluginSpec> foundPlugins; std::string errors; // collect possible plugins for (auto const & plugin : allPlugins) { try { // TODO remove /module hack std::istringstream ss ( lookupInfo (PluginSpec (plugin, KeySet (5, *Key ("system/module", KEY_VALUE, "this plugin was loaded without a config", KEY_END), KS_END)), "metadata")); std::string metadata; while (ss >> metadata) { if (metadata == which) { int s = calculateStatus (lookupInfo ( PluginSpec (plugin, KeySet (5, *Key ("system/module", KEY_VALUE, "this plugin was loaded without a config", KEY_END), KS_END)), "status")); foundPlugins.insert (std::make_pair (s, PluginSpec (plugin))); break; } } } catch (std::exception const & e) { errors += e.what (); errors += ","; } // assume not loaded } if (foundPlugins.empty ()) { if (!errors.empty ()) throw NoPlugin ("No plugin that provides " + which + " could be found, got errors: " + errors); else throw NoPlugin ("No plugin that provides " + which + " could be found"); } // the largest element of the map contains the best-suited plugin: return foundPlugins.rbegin ()->second; }
void QQmlIncubatorPrivate::incubate(QQmlInstantiationInterrupt &i) { if (!compiledData) return; QML_MEMORY_SCOPE_URL(compiledData->url()); QExplicitlySharedDataPointer<QQmlIncubatorPrivate> protectThis(this); QRecursionWatcher<QQmlIncubatorPrivate, &QQmlIncubatorPrivate::recursion> watcher(this); QQmlEngine *engine = compiledData->engine; QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(engine); if (!vmeGuard.isOK()) { QQmlError error; error.setUrl(compiledData->url()); error.setDescription(QQmlComponent::tr("Object destroyed during incubation")); errors << error; progress = QQmlIncubatorPrivate::Completed; goto finishIncubate; } vmeGuard.clear(); if (progress == QQmlIncubatorPrivate::Execute) { enginePriv->referenceScarceResources(); QObject *tresult = 0; tresult = creator->create(subComponentToCreate, /*parent*/0, &i); if (!tresult) errors = creator->errors; enginePriv->dereferenceScarceResources(); if (watcher.hasRecursed()) return; result = tresult; if (errors.isEmpty() && result == 0) goto finishIncubate; if (result) { QQmlData *ddata = QQmlData::get(result); Q_ASSERT(ddata); //see QQmlComponent::beginCreate for explanation of indestructible ddata->indestructible = true; ddata->explicitIndestructibleSet = true; ddata->rootObjectInCreation = false; if (q) q->setInitialState(result); } if (watcher.hasRecursed()) return; if (errors.isEmpty()) progress = QQmlIncubatorPrivate::Completing; else progress = QQmlIncubatorPrivate::Completed; changeStatus(calculateStatus()); if (watcher.hasRecursed()) return; if (i.shouldInterrupt()) goto finishIncubate; } if (progress == QQmlIncubatorPrivate::Completing) { do { if (watcher.hasRecursed()) return; QQmlContextData *ctxt = 0; ctxt = creator->finalize(i); if (ctxt) { rootContext = ctxt; progress = QQmlIncubatorPrivate::Completed; goto finishIncubate; } } while (!i.shouldInterrupt()); } finishIncubate: if (progress == QQmlIncubatorPrivate::Completed && waitingFor.isEmpty()) { QExplicitlySharedDataPointer<QQmlIncubatorPrivate> isWaiting = waitingOnMe; clear(); if (isWaiting) { QRecursionWatcher<QQmlIncubatorPrivate, &QQmlIncubatorPrivate::recursion> watcher(isWaiting.data()); changeStatus(calculateStatus()); if (!watcher.hasRecursed()) isWaiting->incubate(i); } else { changeStatus(calculateStatus()); } enginePriv->inProgressCreations--; if (0 == enginePriv->inProgressCreations) { while (enginePriv->erroredBindings) { enginePriv->warning(enginePriv->erroredBindings); enginePriv->erroredBindings->removeError(); } } } else if (!creator.isNull()) { vmeGuard.guard(creator.data()); } }
void ICharacter::calculateStats () { boost::unique_lock<boost::mutex> statsLock(m_stats_mutex); boost::mutex::scoped_lock property_lock(m_property_mutex); /// SET BASE STATS AND RECALCULATE m_MA = std::make_pair(0,0); m_PA = std::make_pair(0,0); m_PAbs = 0; m_MAbs = 0; m_PD = m_property->PhysicalDefense; m_MD = m_property->MagicalDefense; m_BR = m_property->BlockRatio; m_CR = 0; m_PR = m_property->ParryRatio; m_HR = m_property->HitRatio; m_PBalance = 0; m_MBalance = 0; m_PRate = 0; m_MRate = 0; m_AD = 0; float wlkspeed = m_property->WalkSpeed; float runspeed = m_property->RunSpeed; float bskspeed = m_property->BersekSpeed; property_lock.unlock(); bool hasWall = false; uint32_t curWallHP = m_Effects[STAT_WALL_HP]; m_Effects.clear(); short speed_percent = 0; short hp_percent = 0; short mp_percent = 0; short pr_percent = 0; short hr_percent = 0; short pd_percent = 0; short md_percent = 0; std::vector<std::pair<CHAR_STATS,int32_t> > bonus; calculatePreStats(bonus); boost::mutex::scoped_lock buff_lock(m_buff_mutex); for ( std::map<uint32_t,Buff>::const_iterator k = m_buff_list.begin(); k != m_buff_list.end(); ++k) { for (Skill::buff_const_iterator j = k->second.skill->buff_begin(); j != k->second.skill->buff_end(); ++j) { switch(j->ID) { case BUFF_CRITICAL_INC: m_CR += j->Arg[0]; break; case BUFF_SPEED_INC: case BUFF_SPEED_INC2: case BUFF_SPEED_INC3: speed_percent += j->Arg[0]; break; case BUFF_PARRY_INC: m_PR += j->Arg[0]; pr_percent += j->Arg[1]; break; case BUFF_PARRY_DEC: m_PR -= j->Arg[0]; break; case BUFF_HIT_INC: m_HR += j->Arg[0]; hr_percent += j->Arg[1]; break; case BUFF_HIT_DEC: m_HR -= j->Arg[0]; break; case BUFF_HP_INC: m_MaxHP += j->Arg[0]; hp_percent += j->Arg[1]; break; case BUFF_MP_INC: m_MaxMP += j->Arg[0]; mp_percent += j->Arg[1]; break; case BUFF_RANGE_INC: m_AD += j->Arg[0]; break; case BUFF_DAMAGE_INC: m_PRate += j->Arg[0]; m_MRate += j->Arg[0]; break; case BUFF_INT_INC: case BUFF_STR_INC: case BUFF_SHIELD_PWR_4_DAMAGE: calculateBuffEffects(bonus,*j); break; case BUFF_REINCARNATION: m_Effects[STAT_HP_RGN] += j->Arg[0]; m_Effects[STAT_MP_RGN] += j->Arg[1]; break; case BUFF_IGNORE_DEFENSE: m_Effects[STAT_IGD] += j->Arg[0]; break; case BUFF_CRIT_PARRY_INC: m_Effects[STAT_CPR] += j->Arg[0]; break; case BUFF_GOLD_DROP_INC: m_Effects[STAT_GOLD_DROP] += j->Arg[0]; break; case BUFF_MAGICOPTION_LUCK_INC: m_Effects[STAT_MOL] += j->Arg[0]; break; case BUFF_ENCHANT_LUCK_INC: m_Effects[STAT_ETL] += j->Arg[0]; break; case BUFF_MP_ABSORB: m_Effects[STAT_MP_ABSORB] += j->Arg[0]; break; case BUFF_DAMAGE_PWR_INC: m_PA.first += j->Arg[0]; m_PA.second += j->Arg[0]; m_MA.first += j->Arg[1]; m_MA.second += j->Arg[1]; break; case BUFF_DETECT: case BUFF_DETECT_V2: //(5 Stealth) (6 Invisible) (7 All) //Max level break; case BUFF_HEAL_INC: m_Effects[STAT_HP_HEAL] += j->Arg[0]; m_Effects[STAT_MP_HEAL] += j->Arg[1]; break; case BUFF_ABSORB_WALL: hasWall = true; m_Effects[STAT_WALL] = j->Arg[0] == WALL_TYPE_PHYSICAL; m_Effects[STAT_WALL_MAX] = j->Arg[1]; m_Effects[STAT_WALL_RATE] = j->Arg[3]; m_Effects[STAT_WALL_ID] = k->first; break; case BUFF_BLOCK_INC: //BLOCK TYPE +0 (15 ALL) (11 Magic %) (7 Physical %) //BLOCK RATE +1 m_BR += j->Arg[1]; break; case BUFF_DAMAGE_REFLECT: //PROBABILITY [%] //PHY DAMAGE RETURNED [%] //MAG DAMAGE RETURNED [%] //RETURN RANGE break; case BUFF_ABSORB: //TYPE (3 - Physical Absorb) (12 & 15 - Absorb all) (4 Physical) (8 Magical) (6 Physical ranged) //Amount (%) //0 break; case BUFF_DEFENSE_INC: m_PD += j->Arg[0]; m_MD += j->Arg[1]; //Caster Range break; case BUFF_DEFENSE_DEC: pd_percent -= j->Arg[0]; md_percent -= j->Arg[1]; break; case BUFF_DAMAGE_DEC: m_PRate -= j->Arg[0]; m_MRate -= j->Arg[1]; break; case BUFF_HP_DEC: //Duration //0 hp_percent -= j->Arg[2]; //2 break; default: break; } } } if (hasWall) { uint32_t wallMax = m_Effects[STAT_WALL_MAX]; if (curWallHP > wallMax) m_Effects[STAT_WALL_HP] = wallMax; } buff_lock.unlock(); for (std::vector<std::pair<CHAR_STATS,int32_t> >::const_iterator it = bonus.begin(); it != bonus.end(); ++it) { switch(it->first) { case STAT_HP_PERCENT: hp_percent += it->second; break; case STAT_HR_PERCENT: hr_percent += it->second; break; case STAT_MP_PERCENT: mp_percent += it->second; break; case STAT_PR_PERCENT: pr_percent += it->second; break; default: break; } } calculatePostStats(); if (hp_percent) m_MaxHP = linear_regression(m_MaxHP,hp_percent); if (m_HP > m_MaxHP) m_HP = m_MaxHP; if (mp_percent) m_MaxMP = linear_regression(m_MaxMP,mp_percent); if (m_MP > m_MaxMP) m_MP = m_MaxMP; if (pr_percent) m_PR = linear_regression(m_PR,pr_percent); if (hr_percent) m_HR = linear_regression(m_HR,hr_percent); if (pd_percent) m_PD = linear_regression(m_PD,pd_percent); if (md_percent) m_MD = linear_regression(m_MD,md_percent); if (speed_percent) { wlkspeed = linear_regression(wlkspeed,speed_percent); runspeed = linear_regression(runspeed,speed_percent); bskspeed = linear_regression(bskspeed,speed_percent); } if (IsBerserk()) { wlkspeed *=2; runspeed *=2; bskspeed *=2; m_PA.first *= 2; m_PA.second *= 2; m_MA.first *= 2; m_MA.second *= 2; } m_WalkSpeed = wlkspeed; m_RunSpeed = runspeed; m_BerserkSpeed = bskspeed; calculateStatus(); statsLock.unlock(); if (!signal_stats.empty()) signal_stats(); if (!signal_speed.empty()) signal_speed(m_WalkSpeed,m_RunSpeed); }