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);
}
