Example #1
0
void EffectManager::clearNegativeEffects() {
	for (unsigned i=effect_list.size(); i > 0; i--) {
		if (effect_list[i-1].type == "damage") removeEffect(i-1);
		else if (effect_list[i-1].type == "speed" && effect_list[i-1].magnitude_max < 100) removeEffect(i-1);
		else if (effect_list[i-1].type == "stun") removeEffect(i-1);
	}
}
Example #2
0
void EffectManager::clearNegativeEffects(int type) {
	for (size_t i=effect_list.size(); i > 0; i--) {
		if ((type == -1 || type == EFFECT_IMMUNITY_DAMAGE) && effect_list[i-1].type == EFFECT_DAMAGE)
			removeEffect(i-1);
		else if ((type == -1 || type == EFFECT_IMMUNITY_DAMAGE) && effect_list[i-1].type == EFFECT_DAMAGE_PERCENT)
			removeEffect(i-1);
		else if ((type == -1 || type == EFFECT_IMMUNITY_SLOW) && effect_list[i-1].type == EFFECT_SPEED && effect_list[i-1].magnitude_max < 100)
			removeEffect(i-1);
		else if ((type == -1 || type == EFFECT_IMMUNITY_STUN) && effect_list[i-1].type == EFFECT_STUN)
			removeEffect(i-1);
		else if ((type == -1 || type == EFFECT_KNOCKBACK) && effect_list[i-1].type == EFFECT_KNOCKBACK)
			removeEffect(i-1);
	}
}
Example #3
0
void NeoVibrateAccessory::setVibrateNow(const bool value, int timeoutMs, int strength)
{
    struct input_event event;

    //qLog(Modem) << "setVibrateNow " << value << ", timeoutMs=" << timeoutMs << ", strength=" << strength;

    if (value && rumbleFd < 0)
        rumbleFd = openRumble();

    if (rumbleFd < 0)
        return;

    if (value && effectId < 0)
        effectId = uploadEffect(rumbleFd, (quint16)(strength), timeoutMs);

    if (effectId < 0)
        return;

    // Play/stop the effect
    event.type = EV_FF;
    event.code = effectId;
    event.value = (value ? 1 : 0);

    if (write(rumbleFd, (const void *)&event, sizeof(event)) == -1) {
        perror("rumble write");
    }

    if (!value)
        removeEffect(rumbleFd, effectId, true);

    QVibrateAccessoryProvider::setVibrateNow(value);
}
Example #4
0
void Exit::doDispelMagic(BaseRoom* parent) {
    bringDownTheWall(getEffect("wall-of-fire"), parent, this);
    bringDownTheWall(getEffect("wall-of-thorns"), parent, this);

    // true we'll show, false don't remove perm effects
    removeEffect("concealed", true, false);
}
void EffectManager::addEffect(EffectDef &effect, int duration, int magnitude, bool item, int trigger, int passive_id, int source_type) {
	int effect_type = getType(effect.type);

	// if we're already immune, don't add negative effects
	if (immunity_damage && (effect_type == EFFECT_DAMAGE || effect_type == EFFECT_DAMAGE_PERCENT))
		return;
	else if (immunity_slow && effect_type == EFFECT_SPEED && magnitude < 100)
		return;
	else if (immunity_stun && effect_type == EFFECT_STUN)
		return;
	else if (immunity_knockback && effect_type == EFFECT_KNOCKBACK)
		return;

	// only allow one knockback effect at a time
	if (effect_type == EFFECT_KNOCKBACK && knockback_speed != 0)
		return;

	for (size_t i=effect_list.size(); i>0; i--) {
		if (effect_list[i-1].name == effect.id) {
			if (trigger > -1 && effect_list[i-1].trigger == trigger)
				return; // trigger effects can only be cast once per trigger

			if (!effect.can_stack)
				removeEffect(i-1);
		}
		// if we're adding an immunity effect, remove all negative effects
		if (effect_type == EFFECT_IMMUNITY)
			clearNegativeEffects();
		else if (effect_type == EFFECT_IMMUNITY_DAMAGE)
			clearNegativeEffects(EFFECT_IMMUNITY_DAMAGE);
		else if (effect_type == EFFECT_IMMUNITY_SLOW)
			clearNegativeEffects(EFFECT_IMMUNITY_SLOW);
		else if (effect_type == EFFECT_IMMUNITY_STUN)
			clearNegativeEffects(EFFECT_IMMUNITY_STUN);
		else if (effect_type == EFFECT_IMMUNITY_KNOCKBACK)
			clearNegativeEffects(EFFECT_IMMUNITY_KNOCKBACK);
	}

	Effect e;

	e.name = effect.id;
	e.icon = effect.icon;
	e.type = effect_type;
	e.render_above = effect.render_above;

	if (effect.animation != "") {
		anim->increaseCount(effect.animation);
		e.animation = loadAnimation(effect.animation);
		e.animation_name = effect.animation;
	}

	e.ticks = e.duration = duration;
	e.magnitude = e.magnitude_max = magnitude;
	e.item = item;
	e.trigger = trigger;
	e.passive_id = passive_id;
	e.source_type = source_type;

	effect_list.push_back(e);
}
Example #6
0
void EffectManager::clearEffects() {
	for (unsigned i=effect_list.size(); i > 0; i--) {
		removeEffect(i-1);
	}

	// clear triggers
	triggered_others = triggered_block = triggered_hit = triggered_halfdeath = triggered_joincombat = triggered_death = false;
}
Example #7
0
void Creature::removeStatEffects() {
    Player* pThis = getAsPlayer();
    if(pThis) {
        pThis->loseRage();
        pThis->loseFrenzy();
        pThis->losePray();
    }
    removeEffect("strength");
    removeEffect("enfeeblement");
    removeEffect("haste");
    removeEffect("slow");
    removeEffect("fortitude");
    removeEffect("weakness");
    removeEffect("insight");
    removeEffect("feeblemind");
    removeEffect("prayer");
    removeEffect("damnation");
}
Example #8
0
/**
 * Update this entity's status.
 *
 * Decreases remaining effect durations for entities. Overloading
 * implementations should call this method in their base class to ensure that
 * all time-related processing is completed.
 * @param[in] deferred A vector of actions to be taken some time after
 * the entity's present map has finished ticking.
 * @return true if this entity should be removed from its containing map, false
 * otherwise. The default implementation is guaranteed to return false
 */
bool Entity::tick(std::vector<std::function<void()> > &deferred)
{
    for (int i = 0; i < StatusEffect::SE_KINDS; i++) {
        if (effects[i] && effects[i]->tick(this) <= 0) {
            removeEffect((StatusEffect::Kind) i);
        }
    }

    return false;
}
void MTexturePixmapPrivate::installEffect(MCompositeWindowShaderEffect* effect)
{
    if (effect == prev_effect)
        return;

    if (prev_effect) {
        disconnect(prev_effect, SIGNAL(enabledChanged(bool)), this,
                   SLOT(activateEffect(bool)));
        disconnect(prev_effect, SIGNAL(destroyed()), this,
                   SLOT(removeEffect()));
    }
    current_effect = effect;
    prev_effect = effect;
    if (effect) {
        connect(effect, SIGNAL(enabledChanged(bool)),
                SLOT(activateEffect(bool)), Qt::UniqueConnection);
        connect(effect, SIGNAL(destroyed()), SLOT(removeEffect()),
                Qt::UniqueConnection);
    }
}
Example #10
0
bool Entity::removeEffectId(int seid)
{
    BaseEffect *be = BaseEffect::getById(seid);
    assert(be);
    if (be) {
        if (effects[be->kind] && effects[be->kind]->getId() == seid) {
            return removeEffect((StatusEffect::Kind) be->kind);
        }
    }
    return false;
}
QgsEffectStackPropertiesWidget::QgsEffectStackPropertiesWidget( QgsEffectStack *stack, QWidget *parent )
    : QgsPanelWidget( parent )
    , mStack( stack )
    , mPreviewPicture( nullptr )
{

// TODO
#ifdef Q_OS_MAC
  //setWindowModality( Qt::WindowModal );
#endif

  mPresentWidget = nullptr;

  setupUi( this );

  mAddButton->setIcon( QIcon( QgsApplication::iconPath( "symbologyAdd.svg" ) ) );
  mRemoveButton->setIcon( QIcon( QgsApplication::iconPath( "symbologyRemove.svg" ) ) );
  mUpButton->setIcon( QIcon( QgsApplication::iconPath( "symbologyUp.svg" ) ) );
  mDownButton->setIcon( QIcon( QgsApplication::iconPath( "symbologyDown.svg" ) ) );

  mModel = new QStandardItemModel();
  // Set the effect
  mEffectsList->setModel( mModel );

  QItemSelectionModel* selModel = mEffectsList->selectionModel();
  connect( selModel, SIGNAL( currentChanged( const QModelIndex&, const QModelIndex& ) ), this, SLOT( effectChanged() ) );

  loadStack( stack );
  updatePreview();

  connect( mUpButton, SIGNAL( clicked() ), this, SLOT( moveEffectUp() ) );
  connect( mDownButton, SIGNAL( clicked() ), this, SLOT( moveEffectDown() ) );
  connect( mAddButton, SIGNAL( clicked() ), this, SLOT( addEffect() ) );
  connect( mRemoveButton, SIGNAL( clicked() ), this, SLOT( removeEffect() ) );

  updateUi();

  // set first selected effect as active item in the tree
  int initialRow = 0;
  for ( int i = 0; i < stack->count(); ++i )
  {
    // list shows effects in opposite order to stack
    if ( stack->effect( stack->count() - i - 1 )->enabled() )
    {
      initialRow = i;
      break;
    }
  }
  QModelIndex newIndex = mEffectsList->model()->index( initialRow, 0 );
  mEffectsList->setCurrentIndex( newIndex );

  setPanelTitle( tr( "Effects Properties" ) );
}
Example #12
0
bool EngineEffectChain::processEffectsRequest(const EffectsRequest& message,
                                              EffectsResponsePipe* pResponsePipe) {
    EffectsResponse response(message);
    switch (message.type) {
        case EffectsRequest::ADD_EFFECT_TO_CHAIN:
            if (kEffectDebugOutput) {
                qDebug() << debugString() << "ADD_EFFECT_TO_CHAIN"
                         << message.AddEffectToChain.pEffect
                         << message.AddEffectToChain.iIndex;
            }
            response.success = addEffect(message.AddEffectToChain.pEffect,
                                         message.AddEffectToChain.iIndex);
            break;
        case EffectsRequest::REMOVE_EFFECT_FROM_CHAIN:
            if (kEffectDebugOutput) {
                qDebug() << debugString() << "REMOVE_EFFECT_FROM_CHAIN"
                         << message.RemoveEffectFromChain.pEffect
                         << message.RemoveEffectFromChain.iIndex;
            }
            response.success = removeEffect(message.RemoveEffectFromChain.pEffect,
                                            message.RemoveEffectFromChain.iIndex);
            break;
        case EffectsRequest::SET_EFFECT_CHAIN_PARAMETERS:
            if (kEffectDebugOutput) {
                qDebug() << debugString() << "SET_EFFECT_CHAIN_PARAMETERS"
                         << "enabled" << message.SetEffectChainParameters.enabled
                         << "mix" << message.SetEffectChainParameters.mix;
            }
            response.success = updateParameters(message);
            break;
        case EffectsRequest::ENABLE_EFFECT_CHAIN_FOR_CHANNEL:
            if (kEffectDebugOutput) {
                qDebug() << debugString() << "ENABLE_EFFECT_CHAIN_FOR_CHANNEL"
                         << message.channel;
            }
            response.success = enableForChannel(message.channel);
            break;
        case EffectsRequest::DISABLE_EFFECT_CHAIN_FOR_CHANNEL:
            if (kEffectDebugOutput) {
                qDebug() << debugString() << "DISABLE_EFFECT_CHAIN_FOR_CHANNEL"
                         << message.channel;
            }
            response.success = disableForChannel(message.channel);
            break;
        default:
            return false;
    }
    pResponsePipe->writeMessages(&response, 1);
    return true;
}
Example #13
0
    //-----------------------------------------------------------------------
    void TextureUnitState::setScrollAnimation(Real uSpeed, Real vSpeed)
    {
        // Remove existing effects
        removeEffect(ET_UVSCROLL);
        removeEffect(ET_USCROLL);
        removeEffect(ET_VSCROLL);

        // don't create an effect if the speeds are both 0
        if(uSpeed == 0.0f && vSpeed == 0.0f) 
        {
          return;
        }

        // Create new effect
        TextureEffect eff;
	if(uSpeed == vSpeed) 
	{
		eff.type = ET_UVSCROLL;
		eff.arg1 = uSpeed;
		addEffect(eff);
	}
	else
	{
		if(uSpeed)
		{
			eff.type = ET_USCROLL;
        eff.arg1 = uSpeed;
        addEffect(eff);
    }
		if(vSpeed)
		{
			eff.type = ET_VSCROLL;
			eff.arg1 = vSpeed;
			addEffect(eff);
		}
	}
    }
//---------------------------------------------------------------------------//
RenderEffectManager::~RenderEffectManager()
{
    // Destroy any RenderEffect objects we created that still exist.
    while (!d_effects.empty())
        destroy(*d_effects.begin()->first);

    // Remove (destroy) all the RenderEffectFactory objects.
    while (!d_effectRegistry.empty())
        removeEffect(d_effectRegistry.begin()->first);

    char addr_buff[32];
    sprintf(addr_buff, "(%p)", static_cast<void*>(this));
    Logger::getSingleton().logEvent(
        "CEGUI::RenderEffectManager singleton destroyed " + String(addr_buff));
}
Example #15
0
 //-----------------------------------------------------------------------
 void TextureUnitState::setRotateAnimation(Real speed)
 {
     // Remove existing effect
     removeEffect(ET_ROTATE);
     // don't create an effect if the speed is 0
     if(speed == 0.0f) 
     {
       return;
     }
     // Create new effect
     TextureEffect eff;
     eff.type = ET_ROTATE;
     eff.arg1 = speed;
     addEffect(eff);
 }
Example #16
0
    //-----------------------------------------------------------------------
    void TextureUnitState::setEnvironmentMap(bool enable, EnvMapType envMapType)
    {
        if (enable)
        {
            TextureEffect eff;
            eff.type = ET_ENVIRONMENT_MAP;

            eff.subtype = envMapType;
            addEffect(eff);
        }
        else
        {
            removeEffect(ET_ENVIRONMENT_MAP);
        }
    }
Example #17
0
void EffectManager::removeEffectID(const std::vector< std::pair<std::string, int> >& remove_effects) {
	for (size_t i = 0; i < remove_effects.size(); i++) {
		int count = remove_effects[i].second;
		bool remove_all = (count == 0 ? true : false);

		for (size_t j = effect_list.size(); j > 0; j--) {
			if (!remove_all && count <= 0)
				break;

			if (effect_list[j-1].id == remove_effects[i].first) {
				removeEffect(j-1);
				count--;
			}
		}
	}
}
Example #18
0
    //-----------------------------------------------------------------------
    void TextureUnitState::setProjectiveTexturing(bool enable, 
        const Frustum* projectionSettings)
    {
        if (enable)
        {
            TextureEffect eff;
            eff.type = ET_PROJECTIVE_TEXTURE;
            eff.frustum = projectionSettings;
            addEffect(eff);
        }
        else
        {
            removeEffect(ET_PROJECTIVE_TEXTURE);
        }

    }
Example #19
0
void EffectManager::addEffect(EffectDef &effect, int duration, int magnitude, bool item, int trigger, int passive_id, int source_type) {
	// if we're already immune, don't add negative effects
	if (immunity) {
		if (effect.type == "damage") return;
		else if (effect.type == "speed" && magnitude < 100) return;
		else if (effect.type == "stun") return;
	}

	for (unsigned i=effect_list.size(); i>0; i--) {
		if (effect_list[i-1].name == effect.name) {
			if (trigger > -1 && effect_list[i-1].trigger == trigger)
				return; // trigger effects can only be cast once per trigger

			if (!effect.can_stack)
				removeEffect(i-1);
		}
		// if we're adding an immunity effect, remove all negative effects
		if (effect.type == "immunity") {
			clearNegativeEffects();
		}
	}

	Effect e;

	e.name = effect.name;
	e.icon = effect.icon;
	e.type = effect.type;
	e.render_above = effect.render_above;

	if (effect.animation != "") {
		anim->increaseCount(effect.animation);
		e.animation = loadAnimation(effect.animation);
		e.animation_name = effect.animation;
	}

	e.ticks = e.duration = duration;
	e.magnitude = e.magnitude_max = magnitude;
	e.item = item;
	e.trigger = trigger;
	e.passive_id = passive_id;
	e.source_type = source_type;

	effect_list.push_back(e);
}
Example #20
0
void Attribute::update(float dt)
{
    if(!mEffectList.empty())
    {
        int i = 0;
        cocos2d::Vector<IEffect*> toRemoveEffectList;
        for( ; i < mEffectList.size(); i++ )
        {
            auto pEffect = mEffectList.at(i);
            pEffect->updateEffectStatus(dt);
            if(pEffect->getEffectStatus()  == EffectStatus::OVERDUE)
            {
                toRemoveEffectList.pushBack(pEffect);
            }
        }
        int j = 0;
        for(; j < toRemoveEffectList.size(); j++ )
        {
            auto pToRemoveEffect = toRemoveEffectList.at(j);
            removeEffect(pToRemoveEffect);
        }
        
        if(mIsAttributeDirty)
        {
            mIsAttributeDirty = false;
            int i = 0;
            mAfterEffectValue = mBaseValue;
            mIsLockIncrease = false; //恢复默认状态
            mIsLockDecrease = false; //恢复默认状态
            sortAllEffect();
            for( ; i < mEffectList.size(); i++ )
            {
                auto pEffect = mEffectList.at(i);
                if(pEffect->getEffectStatus() == EffectStatus::EFFECTING)
                {
                    pEffect->calcuAfterEffectValue();
                }
            }
            
        }
    }
}
QgsEffectStackPropertiesWidget::QgsEffectStackPropertiesWidget( QgsEffectStack *stack, QWidget *parent )
    : QWidget( parent )
    , mStack( stack )
    , mPreviewPicture( 0 )
{

// TODO
#ifdef Q_OS_MAC
  //setWindowModality( Qt::WindowModal );
#endif

  mPresentWidget = NULL;

  setupUi( this );

  mAddButton->setIcon( QIcon( QgsApplication::iconPath( "symbologyAdd.svg" ) ) );
  mRemoveButton->setIcon( QIcon( QgsApplication::iconPath( "symbologyRemove.svg" ) ) );
  mUpButton->setIcon( QIcon( QgsApplication::iconPath( "symbologyUp.svg" ) ) );
  mDownButton->setIcon( QIcon( QgsApplication::iconPath( "symbologyDown.svg" ) ) );

  mModel = new QStandardItemModel();
  // Set the effect
  mEffectsList->setModel( mModel );

  QItemSelectionModel* selModel = mEffectsList->selectionModel();
  connect( selModel, SIGNAL( currentChanged( const QModelIndex&, const QModelIndex& ) ), this, SLOT( effectChanged() ) );

  loadStack( stack );
  updatePreview();

  connect( mUpButton, SIGNAL( clicked() ), this, SLOT( moveEffectUp() ) );
  connect( mDownButton, SIGNAL( clicked() ), this, SLOT( moveEffectDown() ) );
  connect( mAddButton, SIGNAL( clicked() ), this, SLOT( addEffect() ) );
  connect( mRemoveButton, SIGNAL( clicked() ), this, SLOT( removeEffect() ) );

  updateUi();

  // set effect as active item in the tree
  QModelIndex newIndex = mEffectsList->model()->index( 0, 0 );
  mEffectsList->setCurrentIndex( newIndex );
}
Example #22
0
bool SDL2FFBDevice::removeAndEraseEffect(const int idx)
{
  CHECK_EFFECT_IDX(idx);

  if (m_effects[idx]->status() == FFBEffect::FFBEffectStatus::NOT_LOADED)
    return true;

  if (removeEffect(idx)) {
    m_effects[idx] = SDL2FFBEffectFactory::createEffect(FFBEffectTypes::NONE);
    if (m_effects[idx]->type() != FFBEffectTypes::NONE) {
      qCritical("Unable to empty the effect slot.");
      return false;
    }
  } else {
    qCritical("Unable to stop the effect.");
    return false;
  }

  m_effects[idx]->setStatus(FFBEffect::FFBEffectStatus::NOT_LOADED);
  return true;
}
Example #23
0
bool Player::checkOppositeResistSpell(bstring effect) {
    if(effect == "resist-cold" )
        removeEffect("resist-fire");
    else if(effect == "resist-fire" )
        removeEffect("resist-cold");
    else if(effect == "resist-earth" )
        removeEffect("resist-air");
    else if(effect == "resist-air" )
        removeEffect("resist-earth");
    else if(effect == "resist-water" )
        removeEffect("resist-electric");
    else if(effect == "resist-electric" )
        removeEffect("resist-water");
    else
        return(false);

    return(true);
}
Example #24
0
void Entity::struck(Entity *eatk, float dmg)
{
    int idmg;
    if (dmg > 1000000000.0)
        idmg = 1000000000;
    else
        idmg = (int) ceil(dmg);

    if (effects[StatusEffect::INVULNERABILITY]) {
        //cant strike me
        return;
    }

    if (effects[StatusEffect::SLEEP]) {
        idmg <<= 1;
        removeEffect(StatusEffect::SLEEP);
    }

    this->damage(eatk, idmg);

    m->forEachNearby(this, [&](Entity *e) {
        e->entityStruck(this, this->getDispHp(), 1);
    });
}
Example #25
0
void PickableModel::onUnpicked() {
	removeEffect(mPickedEffect);
}
Example #26
0
void EffectManager::logic() {
	clearStatus();

	for (unsigned i=0; i<effect_list.size(); i++) {
		// expire timed effects and total up magnitudes of active effects
		if (effect_list[i].duration >= 0) {
			if (effect_list[i].type == "damage" && effect_list[i].ticks % MAX_FRAMES_PER_SEC == 1) damage += effect_list[i].magnitude;
			else if (effect_list[i].type == "hpot" && effect_list[i].ticks % MAX_FRAMES_PER_SEC == 1) hpot += effect_list[i].magnitude;
			else if (effect_list[i].type == "mpot" && effect_list[i].ticks % MAX_FRAMES_PER_SEC == 1) mpot += effect_list[i].magnitude;
			else if (effect_list[i].type == "speed") speed = (effect_list[i].magnitude * speed) / 100;
			else if (effect_list[i].type == "immunity") immunity = true;
			else if (effect_list[i].type == "stun") stun = true;
			else if (effect_list[i].type == "revive") revive = true;
			else if (effect_list[i].type == "convert") convert = true;
			else if (effect_list[i].type == "fear") fear = true;
			else if (effect_list[i].type == "offense") bonus_offense += effect_list[i].magnitude;
			else if (effect_list[i].type == "defense") bonus_defense += effect_list[i].magnitude;
			else if (effect_list[i].type == "physical") bonus_physical += effect_list[i].magnitude;
			else if (effect_list[i].type == "mental") bonus_mental += effect_list[i].magnitude;
			else {
				bool found_key = false;

				for (unsigned j=0; j<STAT_COUNT; j++) {
					if (effect_list[i].type == STAT_NAME[j]) {
						bonus[j] += effect_list[i].magnitude;
						found_key = true;
					}
				}

				if (!found_key) {
					for (unsigned j=0; j<bonus_resist.size(); j++) {
						if (effect_list[i].type == ELEMENTS[j].name + "_resist")
							bonus_resist[j] += effect_list[i].magnitude;
					}
				}
			}

			if (effect_list[i].duration > 0) {
				if (effect_list[i].ticks > 0) effect_list[i].ticks--;
				if (effect_list[i].ticks == 0) {
					//death sentence is only applied at the end of the timer
					if (effect_list[i].type == "death_sentence") death_sentence = true;
					removeEffect(i);
					i--;
					continue;
				}
			}
		}
		// expire shield effects
		if (effect_list[i].magnitude_max > 0 && effect_list[i].magnitude == 0) {
			if (effect_list[i].type == "shield") {
				removeEffect(i);
				i--;
				continue;
			}
		}
		// expire effects based on animations
		if ((effect_list[i].animation && effect_list[i].animation->isLastFrame()) || !effect_list[i].animation) {
			if (effect_list[i].type == "heal") {
				removeEffect(i);
				i--;
				continue;
			}
		}

		// animate
		if (effect_list[i].animation) {
			if (!effect_list[i].animation->isCompleted())
				effect_list[i].animation->advanceFrame();
		}
	}
}
Example #27
0
void EffectManager::removeEffectType(std::string type) {
	for (unsigned i=effect_list.size(); i > 0; i--) {
		if (effect_list[i-1].type == type) removeEffect(i-1);
	}
}
Example #28
0
void EffectManager::clearTriggerEffects(int trigger) {
	for (unsigned i=effect_list.size(); i > 0; i--) {
		if (effect_list[i-1].trigger > -1 && effect_list[i-1].trigger == trigger) removeEffect(i-1);
	}
}
Example #29
0
void EffectManager::clearItemEffects() {
	for (unsigned i=effect_list.size(); i > 0; i--) {
		if (effect_list[i-1].item) removeEffect(i-1);
	}
}
Example #30
0
void EffectManager::removeEffectPassive(int id) {
	for (unsigned i=effect_list.size(); i > 0; i--) {
		if (effect_list[i-1].passive_id == id) removeEffect(i-1);
	}
}