1 files changed, 120 insertions, 0 deletions
diff --git a/src/game-server/autoattack.h b/src/game-server/autoattack.h
new file mode 100644
index 00000000..8be5c608
--- /dev/null
+++ b/src/game-server/autoattack.h
@@ -0,0 +1,120 @@
+/*
+ *  The Mana Server
+ *  Copyright (C) 2010  The Mana 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 AUTOATTACK_H
+#define AUTOATTACK_H
+
+#include <list>
+#include <limits>
+
+/**
+ * Methods of damage calculation
+ */
+enum DMG_TY
+{
+    DAMAGE_PHYSICAL = 0,
+    DAMAGE_MAGICAL,
+    DAMAGE_DIRECT,
+    DAMAGE_OTHER = -1
+};
+
+/**
+ * Structure that describes the severity and nature of an attack a being can
+ * be hit by.
+ */
+struct Damage
+{
+    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. */
+    DMG_TY 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 */
+    Damage(unsigned short base, unsigned short delta, unsigned short cth,
+           unsigned char element, DMG_TY 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) {}
+};
+
+/**
+ * Class that stores information about an auto-attack
+ */
+
+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) {}
+        unsigned short getTimer() const { return mTimer; }
+        bool tick() { return mTimer ? !--mTimer : false; }
+        void reset() { mTimer = mAspd; }
+        bool operator<(const AutoAttack &rhs) const
+        { return mTimer < rhs.getTimer(); }
+        bool isReady() const { return !(mTimer - mWarmup); }
+        void halt() { if (mTimer >= mWarmup) mTimer = 0; }
+        void softReset() { if (mTimer >= mWarmup) mTimer = mAspd; }
+        const Damage &getDamage() const { return mDamage; }
+    private:
+        Damage mDamage;
+        /**
+         * Internal timer that is modified each tick.
+         * When > warmup, the attack is warming up before a strike
+         * When = warmup, the attack triggers, dealing damage to the target *if* the target is still in range.
+         *  (The attack is canceled when the target moves out of range before the attack can hit, there should be a trigger for scripts here too)
+         *  (Should the character automatically persue when the target is still visible in this case?)
+         * When < warmup, the attack is cooling down after a strike. When in cooldown, the timer should not be soft-reset.
+         * When 0, the attack is inactive (the character is doing something other than attacking and the attack is not in cooldown)
+         */
+        unsigned short mTimer;
+        unsigned short mAspd; // Value to reset the timer to (warmup + cooldown)
+        /**
+         * Pre-attack delay tick.
+         * This MUST be smaller than or equal to the aspd!
+         * So the attack triggers where timer == warmup, having gone through aspd - warmup ticks.
+         */
+        unsigned short mWarmup;
+};
+
+/**
+ * Helper class for storing multiple auto-attacks.
+ */
+class AutoAttacks
+{
+    public:
+
+        /**
+         * Whether the being has at least one auto attack that is ready.
+         */
+        void add(AutoAttack n);
+        void clear(); // Wipe the list completely (used in place of remove for now; FIXME)
+        void start();
+        void stop(); // If the character does some action other than attacking, reset all warmups (NOT cooldowns!)
+        void tick(std::list<AutoAttack> *ret = 0);
+    private:
+        bool mActive; /**< Marks whether or not to keep auto-attacking. Cooldowns still need to be processed when false. */
+        std::list < AutoAttack > mAutoAttacks;
+
+};
+
+#endif // AUTOATTACK_H