/*
* The Mana Server
* Copyright (C) 2004-2010 The Mana World Development Team
*
* This file is part of The Mana Server.
*
* The Mana Server is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* The Mana Server is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with The Mana Server. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef ATTRIBUTE_H
#define ATTRIBUTE_H
#include "common/defines.h"
#include "attributemanager.h"
#include <vector>
#include <list>
class AttributeModifierState
{
public:
AttributeModifierState(unsigned short duration,
double value,
unsigned id)
: mDuration(duration)
, mValue(value)
, mId(id)
{}
bool tick() { return mDuration ? !--mDuration : false; }
private:
/** Number of ticks (0 means permanent, e.g. equipment). */
unsigned short mDuration;
const double mValue; /**< Positive or negative amount. */
/**
* Special purpose variable used to identify this effect to
* dispells or similar. Exact usage depends on the effect,
* origin, etc.
*/
const unsigned mId;
friend bool durationCompare(const AttributeModifierState*,
const AttributeModifierState*);
friend class AttributeModifiersEffect;
};
class AttributeModifiersEffect
{
public:
AttributeModifiersEffect(StackableType stackableType,
ModifierEffectType effectType);
~AttributeModifiersEffect();
/**
* Recalculates the value for this level.
* @returns True if the value changed, false if it did not change.
* Note that this will not change values at a higher level, nor the
* overall modified value for this attribute.
* If this returns true, the cached values for *all* modifiers of a
* higher level must be recalculated, as well as the final
*/
bool add(unsigned short duration, double value,
double prevLayerValue, int level);
/**
* remove() - as with Attribute::remove().
*/
bool remove(double value, unsigned id, bool fullCheck);
/**
* Performs the necessary modifications to mMod when the states change.
* @param value The value to alter. This is only used in stackable
* types, as the effect can be simply inverted there.
* For non stackable types (and stackable multiplicative types
* where the value is zero), mMod must be recalculated from all
* current modifiers.
* @note This /negates/ the effect of value.
* @note A parameter should always be provided when stackable.
*/
void updateMod(double value = 0);
/**
* Performs the necessary modifications to mCacheVal when the states
* change.
*/
bool recalculateModifiedValue(double newPrevLayerValue);
double getCachedModifiedValue() const { return mCacheVal; }
bool tick();
/**
* clearMods() - removes all modifications present in this layer.
* This only really makes sense when all other layers are being reset too.
* @param baseValue the value to reset to - typically an Attribute's mBase
*/
void clearMods(double baseValue);
private:
/** List of all modifications present at this level */
std::list<AttributeModifierState *> mStates;
/**
* Stores the value that results from mStates. This takes into
* account all previous layers.
*/
double mCacheVal;
/**
* Stores the effective modifying value from mStates. This defaults to
* 0 for additive modifiers and 1 for multiplicative modifiers.
*/
double mMod;
const StackableType mStackableType;
const ModifierEffectType mEffectType;
};
/**
* Represents some attribute of a being. Is has a base value and a modified
* value, subject to modifiers that can be added and removed.
*/
class Attribute
{
public:
Attribute()
: mBase(0)
, mMinValue(0)
, mMaxValue(0)
{throw;} // DEBUG; Find improper constructions
Attribute(const AttributeManager::AttributeInfo &info);
~Attribute();
void setBase(double base);
double getBase() const { return mBase; }
double getModifiedAttribute() const
{ return mMods.empty() ? mBase :
(*mMods.rbegin())->getCachedModifiedValue(); }
/*
* add() and remove() are the standard functions used to add and
* remove modifiers while keeping track of the modifier state.
*/
/**
* @param duration The amount of time before the modifier expires
* naturally.
* When set to 0, the effect does not expire.
* @param value The value to be applied as the modifier.
* @param layer The id of the layer with which this modifier is to be
* applied to.
* @param id Used to identify this effect.
* @return Whether the modified attribute value was changed.
*/
bool add(unsigned short duration, double value, unsigned layer, int id = 0);
/**
* @param value The value of the modifier to be removed.
* - When 0, id is used exclusively to identify modifiers.
* @param layer The id of the layer which contains the modifier to be removed.
* @param id Used to identify this effect.
* - When 0, only the first match will be removed.
* - When non-0, all modifiers matching this id and other
* parameters will be removed.
* @param fullcheck Whether to perform a check for all modifiers,
* or only those that are otherwise permanent (ie. duration of 0)
* @returns Whether the modified attribute value was changed.
*/
bool remove(double value, unsigned layer, int id, bool fullcheck);
/**
* clearMods() removes *all* modifications present in this Attribute (!)
*/
void clearMods();
/**
* tick() processes all timers associated with modifiers for this attribute.
*/
bool tick();
private:
/**
* Checks the min and max permitted values for the given base value
* and return the adjusted value.
*/
double checkBounds(double baseValue);
double mBase; // The attribute base value
double mMinValue; // The min authorized base and derived attribute value
double mMaxValue; // The max authorized base and derived attribute value
std::vector<AttributeModifiersEffect *> mMods;
};
#endif // ATTRIBUTE_H
