Added possibility to make a being attack an other being

This allows the script to let the character perform a scripted attack but
the character still gets xp and killed monsters give drops.

You can now call:
mana.being_damage(target, dmg, dmg_delta, accurancy, type, element, source,
skill)

While on it I also added checks to the being_damage function.

Reviewed-by: bjorn, Bertram.

4 files changed, 61 insertions, 35 deletions

diff --git a/src/game-server/autoattack.h b/src/game-server/autoattack.h
index 5995d248..e7b853d3 100644
--- a/src/game-server/autoattack.h
+++ b/src/game-server/autoattack.h
@@ -26,6 +26,8 @@
 
 #include "common/defines.h"
 
+#include "game-server/skillmanager.h"
+
 /**
  * Structure that describes the severity and nature of an attack a being can
  * be hit by.
@@ -41,21 +43,15 @@ struct Damage
     bool trueStrike;                /**< Override dodge calculation */
     unsigned short range;           /**< Maximum distance that this attack can be used from, in pixels */
 
-    Damage(unsigned int skill,
-           unsigned short base,
-           unsigned short delta,
-           unsigned short cth,
-           unsigned char element,
-           DamageType type = DAMAGE_OTHER,
-           unsigned short range = DEFAULT_TILE_LENGTH):
-        skill(skill),
-        base(base),
-        delta(delta),
-        cth(cth),
-        element(element),
-        type(type),
+    Damage():
+        skill(0),
+        base(0),
+        delta(0),
+        cth(0),
+        element(ELEMENT_NEUTRAL),
+        type(DAMAGE_OTHER),
         trueStrike(false),
-        range(range)
+        range(DEFAULT_TILE_LENGTH)
     {}
 };
 
diff --git a/src/game-server/character.cpp b/src/game-server/character.cpp
index 950c6496..14b49bca 100644
--- a/src/game-server/character.cpp
+++ b/src/game-server/character.cpp
@@ -186,11 +186,15 @@ void Character::perform()
     {
         int damageBase = getModifiedAttribute(ATTR_STR);
         int damageDelta = damageBase / 2;
-        Damage knuckleDamage(skillManager->getDefaultSkillId(),
-                             damageBase, damageDelta, 2, ELEMENT_NEUTRAL,
-                            DAMAGE_PHYSICAL,
-                            (getSize() < DEFAULT_TILE_LENGTH) ?
-                                DEFAULT_TILE_LENGTH : getSize());
+        Damage knuckleDamage;
+        knuckleDamage.skill = skillManager->getDefaultSkillId();
+        knuckleDamage.base = damageBase;
+        knuckleDamage.delta = damageDelta;
+        knuckleDamage.cth = 2;
+        knuckleDamage.element = ELEMENT_NEUTRAL;
+        knuckleDamage.type = DAMAGE_PHYSICAL;
+        knuckleDamage.range = (getSize() < DEFAULT_TILE_LENGTH) ?
+                    DEFAULT_TILE_LENGTH : getSize();
 
         AutoAttack knuckleAttack(knuckleDamage, 7, 3);
         mAutoAttacks.add(knuckleAttack);
diff --git a/src/game-server/monster.cpp b/src/game-server/monster.cpp
index b82f4638..1e68892d 100644
--- a/src/game-server/monster.cpp
+++ b/src/game-server/monster.cpp
@@ -127,15 +127,15 @@ void Monster::perform()
                 {
                     setTimerHard(T_M_ATTACK_TIME, mCurrentAttack->aftDelay
                                                   + mCurrentAttack->preDelay);
-                    Damage dmg(0,
-                               getModifiedAttribute(MOB_ATTR_PHY_ATK_MIN) *
-                                    mCurrentAttack->damageFactor,
-                               getModifiedAttribute(MOB_ATTR_PHY_ATK_DELTA) *
-                                    mCurrentAttack->damageFactor,
-                               getModifiedAttribute(ATTR_ACCURACY),
-                               mCurrentAttack->element,
-                               mCurrentAttack->type,
-                               mCurrentAttack->range);
+                    Damage dmg;
+                    dmg.skill = 0;
+                    dmg.base = getModifiedAttribute(MOB_ATTR_PHY_ATK_MIN) *
+                            mCurrentAttack->damageFactor;
+                    dmg.delta = getModifiedAttribute(MOB_ATTR_PHY_ATK_DELTA) *
+                            mCurrentAttack->damageFactor;
+                    dmg.cth = getModifiedAttribute(ATTR_ACCURACY);
+                    dmg.element = mCurrentAttack->element;
+                    dmg.range = mCurrentAttack->range;
 
                     int hit = performAttack(mTarget, dmg);
 
diff --git a/src/scripting/lua.cpp b/src/scripting/lua.cpp
index f98fa849..bdbb3110 100644
--- a/src/scripting/lua.cpp
+++ b/src/scripting/lua.cpp
@@ -1001,22 +1001,48 @@ static int being_say(lua_State *s)
 
 /**
  * mana.being_damage(Being* victim, int value, int delta, int cth, int type,
- *                   int element): void
+ *                   int element [, Being* source [, int skill]]): void
  * Applies combat damage to a being.
  */
 static int being_damage(lua_State *s)
 {
     Being *being = checkBeing(s, 1);
 
+    if (!being)
+    {
+        raiseScriptError(s, "being_damage called with invalid victim");
+        return 0;
+    }
     if (!being->canFight())
+    {
+        raiseScriptError(s, "being_damage called with "
+                            "victim that cannot fight");
         return 0;
+    }
 
-    Damage dmg((unsigned short) lua_tointeger(s, 2), /* base */
-               (unsigned short) lua_tointeger(s, 3), /* delta */
-               (unsigned short) lua_tointeger(s, 4), /* cth */
-               (unsigned char)  lua_tointeger(s, 6), /* element */
-               DAMAGE_PHYSICAL);                     /* type */
-    being->damage(NULL, dmg);
+    Damage dmg;
+    dmg.base = luaL_checkint(s, 2);
+    dmg.delta = luaL_checkint(s, 3);
+    dmg.cth = luaL_checkint(s, 4);
+    dmg.type = (DamageType)luaL_checkint(s, 5);
+    dmg.element = luaL_checkint(s, 6);
+    Being *source = 0;
+    if (lua_gettop(s) >= 7)
+    {
+        source = checkBeing(s, 7);
+        if (!source)
+        {
+            raiseScriptError(s, "being_damage called withd invalid source");
+        }
+        if (!source->canFight())
+        {
+            raiseScriptError(s, "being_damage called with "
+                                "source that cannot fight");
+            return 0;
+        }
+    }
+    dmg.skill = luaL_optint(s, 8, 0);
+    being->damage(source, dmg);
 
     return 0;
 }