Started to fix the autoattack system.

I simply made the default autoattack look for the default skill
and add exp to it when killing monsters.

Now the player can earn xp again even if it's not well handled
between two logins.

5 files changed, 47 insertions, 46 deletions

diff --git a/src/common/defines.h b/src/common/defines.h
index c14aca50..140a6929 100644
--- a/src/common/defines.h
+++ b/src/common/defines.h
@@ -126,6 +126,17 @@ enum Element
 };
 
 /**
+ * Damage type, used to know how to compute them.
+ */
+enum DamageType
+{
+    DAMAGE_PHYSICAL = 0,
+    DAMAGE_MAGICAL,
+    DAMAGE_DIRECT,
+    DAMAGE_OTHER = -1
+};
+
+/**
  * A series of hardcoded attributes that must be defined.
  * FIXME: Much of these serve only to indicate derivatives, and so would not be
  * needed once this is no longer a hardcoded system.
diff --git a/src/game-server/attributemanager.cpp b/src/game-server/attributemanager.cpp
index 31566bed..bb307846 100644
--- a/src/game-server/attributemanager.cpp
+++ b/src/game-server/attributemanager.cpp
@@ -97,7 +97,10 @@ bool AttributeManager::isAttributeDirectlyModifiable(int id) const
 
 ModifierLocation AttributeManager::getLocation(const std::string &tag) const
 {
-    return mTagMap.at(tag);
+    if (mTagMap.find(tag) != mTagMap.end())
+        return mTagMap.at(tag);
+    else
+        return ModifierLocation(0, 0);
 }
 
 const std::string *AttributeManager::getTag(const ModifierLocation &location) const
diff --git a/src/game-server/autoattack.h b/src/game-server/autoattack.h
index 2e891fa9..5995d248 100644
--- a/src/game-server/autoattack.h
+++ b/src/game-server/autoattack.h
@@ -23,18 +23,8 @@
 
 #include <cstddef>
 #include <list>
-#include <limits>
 
-/**
- * Methods of damage calculation
- */
-enum DamageType
-{
-    DAMAGE_PHYSICAL = 0,
-    DAMAGE_MAGICAL,
-    DAMAGE_DIRECT,
-    DAMAGE_OTHER = -1
-};
+#include "common/defines.h"
 
 /**
  * Structure that describes the severity and nature of an attack a being can
@@ -42,28 +32,30 @@ enum DamageType
  */
 struct Damage
 {
+    unsigned int skill;             /**< Skill used by source (needed for exp calculation) */
     unsigned short base;            /**< Base amount of damage. */
     unsigned short delta;           /**< Additional damage when lucky. */
     unsigned short cth;             /**< Chance to hit. Opposes the evade attribute. */
     unsigned char element;          /**< Elemental damage. */
     DamageType type;                /**< Damage type: Physical or magical? */
-    unsigned trueStrike : 1;        /**< Override dodge calculation */
-    std::list<size_t> usedSkills;   /**< Skills used by source (needed for exp calculation) */
-    unsigned short range;           /**< Maximum distance that this attack can be used from */
+    bool trueStrike;                /**< Override dodge calculation */
+    unsigned short range;           /**< Maximum distance that this attack can be used from, in pixels */
 
-    Damage(unsigned short base,
+    Damage(unsigned int skill,
+           unsigned short base,
            unsigned short delta,
            unsigned short cth,
            unsigned char element,
            DamageType type = DAMAGE_OTHER,
-           unsigned short range = std::numeric_limits<unsigned short>::max())
-        : base(base)
-        , delta(delta)
-        , cth(cth)
-        , element(element)
-        , type(type)
-        , trueStrike(false)
-        , range(range)
+           unsigned short range = DEFAULT_TILE_LENGTH):
+        skill(skill),
+        base(base),
+        delta(delta),
+        cth(cth),
+        element(element),
+        type(type),
+        trueStrike(false),
+        range(range)
     {}
 };
 
@@ -74,11 +66,11 @@ struct Damage
 class AutoAttack
 {
     public:
-        AutoAttack(Damage &damage, unsigned int delay, unsigned int warmup)
-            : mDamage(damage)
-            , mTimer(0)
-            , mAspd(delay)
-            , mWarmup(warmup && warmup < delay ? warmup : delay >> 2)
+        AutoAttack(Damage &damage, unsigned int warmup, unsigned int cooldown):
+            mDamage(damage),
+            mTimer(0),
+            mAspd(cooldown),
+            mWarmup(warmup && warmup < cooldown ? warmup : cooldown >> 2)
         {}
 
         unsigned short getTimer() const { return mTimer; }
diff --git a/src/game-server/character.cpp b/src/game-server/character.cpp
index 0cac8cfa..0cdd57b1 100644
--- a/src/game-server/character.cpp
+++ b/src/game-server/character.cpp
@@ -36,6 +36,7 @@
 #include "game-server/gamehandler.h"
 #include "game-server/mapcomposite.h"
 #include "game-server/mapmanager.h"
+#include "game-server/skillmanager.h"
 #include "game-server/state.h"
 #include "game-server/trade.h"
 #include "scripting/script.h"
@@ -161,7 +162,8 @@ void Character::perform()
     {
         int damageBase = getModifiedAttribute(ATTR_STR);
         int damageDelta = damageBase / 2;
-        Damage knuckleDamage(damageBase, damageDelta, 2, ELEMENT_NEUTRAL,
+        Damage knuckleDamage(skillManager->getDefaultSkillId(),
+                             damageBase, damageDelta, 2, ELEMENT_NEUTRAL,
                             DAMAGE_PHYSICAL,
                             (getSize() < DEFAULT_TILE_LENGTH) ?
                                 DEFAULT_TILE_LENGTH : getSize());
diff --git a/src/game-server/monster.cpp b/src/game-server/monster.cpp
index d0c55073..0f387917 100644
--- a/src/game-server/monster.cpp
+++ b/src/game-server/monster.cpp
@@ -131,7 +131,8 @@ void Monster::perform()
                 {
                     setTimerHard(T_M_ATTACK_TIME, mCurrentAttack->aftDelay
                                                   + mCurrentAttack->preDelay);
-                    Damage dmg(getModifiedAttribute(MOB_ATTR_PHY_ATK_MIN) *
+                    Damage dmg(0,
+                               getModifiedAttribute(MOB_ATTR_PHY_ATK_MIN) *
                                     mCurrentAttack->damageFactor,
                                getModifiedAttribute(MOB_ATTR_PHY_ATK_DELTA) *
                                     mCurrentAttack->damageFactor,
@@ -421,22 +422,14 @@ int Monster::damage(Actor *source, const Damage &damage)
     {
         Character *s = static_cast< Character * >(source);
 
-        std::list<size_t>::const_iterator iSkill;
-        for (iSkill = damage.usedSkills.begin();
-             iSkill != damage.usedSkills.end(); ++iSkill)
+        mExpReceivers[s].insert(damage.skill);
+        if (!isTimerRunning(T_M_KILLSTEAL_PROTECTED) || mOwner == s
+            || mOwner->getParty() == s->getParty())
         {
-            if (*iSkill)
-            {
-                mExpReceivers[s].insert(*iSkill);
-                if (!isTimerRunning(T_M_KILLSTEAL_PROTECTED) || mOwner == s
-                    || mOwner->getParty() == s->getParty())
-                {
-                    mOwner = s;
-                    mLegalExpReceivers.insert(s);
-                    setTimerHard(T_M_KILLSTEAL_PROTECTED,
-                                 KILLSTEAL_PROTECTION_TIME);
-                }
-            }
+            mOwner = s;
+            mLegalExpReceivers.insert(s);
+            setTimerHard(T_M_KILLSTEAL_PROTECTED,
+                         KILLSTEAL_PROTECTION_TIME);
         }
     }
     return HPLoss;