Renamed .hpp files into .h for consistency.

Also added an header to the autoattack.{h,cpp} files.

Big but trivial fix.

1 files changed, 275 insertions, 0 deletions

diff --git a/src/account-server/character.h b/src/account-server/character.h
new file mode 100644
index 00000000..e43b61a1
--- /dev/null
+++ b/src/account-server/character.h
@@ -0,0 +1,275 @@
+/*
+ *  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 CHARACTERDATA_H
+#define CHARACTERDATA_H
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include "defines.h"
+#include "point.h"
+#include "common/inventorydata.h"
+
+class Account;
+class MessageIn;
+class MessageOut;
+
+typedef std::map< unsigned int, std::pair<double, double> > AttributeMap;
+
+/** placeholder type needed for include compatibility with game server*/
+typedef void Special;
+
+class Character
+{
+    public:
+
+        Character(const std::string &name, int id = -1);
+
+        /**
+         * Gets the database id of the character.
+         */
+        int getDatabaseID() const { return mDatabaseID; }
+        void setDatabaseID(int id) { mDatabaseID = id; }
+
+        /** Gets the account the character belongs to. */
+        Account *getAccount() const
+        { return mAccount; }
+
+        /** Sets the account the character belongs to, and related fields. */
+        void setAccount(Account *ptr);
+
+        /**
+         * Gets the ID of the account the character belongs to.
+         */
+        int getAccountID() const { return mAccountID; }
+        void setAccountID(int id) { mAccountID = id; }
+
+        /**
+         * Gets the name of the character.
+         */
+        const std::string &getName() const { return mName; }
+        void setName(const std::string &name) { mName = name; }
+
+        /**
+         * Gets the gender of the character (male / female).
+         */
+        int getGender() const { return mGender; }
+        void setGender(int gender) { mGender = gender; }
+
+        /**
+         * Gets the hairstyle of the character.
+         */
+        int getHairStyle() const { return mHairStyle; }
+        void setHairStyle(int style) { mHairStyle = style; }
+
+        /**
+         * Gets the haircolor of the character.
+         */
+        int getHairColor() const { return mHairColor; }
+        void setHairColor(int color) { mHairColor = color; }
+
+        /** Gets the account level of the user. */
+        int getAccountLevel() const
+        { return mAccountLevel; }
+
+        /**
+          * Sets the account level of the user.
+          * @param force ensure the level is not modified by a game server.
+          */
+        void setAccountLevel(int l, bool force = false)
+        { if (force) mAccountLevel = l; }
+
+        /**
+         * Gets the level of the character.
+         */
+        int getLevel() const { return mLevel; }
+        void setLevel(int level) { mLevel = level; }
+
+        /** Sets the value of a base attribute of the character. */
+        void setAttribute(unsigned int id, double value)
+        { mAttributes[id].first = value; }
+
+        void setModAttribute(unsigned int id, double value)
+        { mAttributes[id].second = value; }
+
+        int getSkillSize() const
+        { return mExperience.size(); }
+
+        const std::map<int, int>::const_iterator getSkillBegin() const
+        { return mExperience.begin(); }
+
+        const std::map<int, int>::const_iterator getSkillEnd() const
+        { return mExperience.end(); }
+
+        int getExperience(int skill) const
+        { return mExperience.find(skill)->second; }
+
+        void setExperience(int skill, int value)
+        { mExperience[skill] = value; }
+
+        void receiveExperience(int skill, int value)
+        { mExperience[skill] += value; }
+
+        /**
+         * Get / Set a status effects
+         */
+        void applyStatusEffect(int id, int time)
+        { mStatusEffects[id] = time; }
+
+        int getStatusEffectSize() const
+        { return mStatusEffects.size(); }
+
+        const std::map<int, int>::const_iterator getStatusEffectBegin() const
+        { return mStatusEffects.begin(); }
+
+        const std::map<int, int>::const_iterator getStatusEffectEnd() const
+        { return mStatusEffects.end(); }
+
+        /**
+         * Get / Set kill count
+         */
+        int getKillCountSize() const
+        { return mKillCount.size(); }
+
+        const std::map<int, int>::const_iterator getKillCountBegin() const
+        { return mKillCount.begin(); }
+
+        const std::map<int, int>::const_iterator getKillCountEnd() const
+        { return mKillCount.end(); }
+
+        void setKillCount(int monsterId, int kills)
+        { mKillCount[monsterId] = kills; }
+
+        /**
+         * Get / Set specials
+         */
+        int getSpecialSize() const
+        { return mSpecials.size(); }
+
+        const std::map<int, Special*>::const_iterator getSpecialBegin() const
+        { return mSpecials.begin(); }
+
+        const std::map<int, Special*>::const_iterator getSpecialEnd() const
+        { return mSpecials.end(); }
+
+        void clearSpecials()
+        { mSpecials.clear(); }
+
+        void giveSpecial(int id)
+        { mSpecials[id] = NULL; }
+
+        /**
+         * Gets the Id of the map that the character is on.
+         */
+        int getMapId() const { return mMapId; }
+        void setMapId(int mapId) { mMapId = mapId; }
+
+        /**
+         * Gets the position of the character on the map.
+         */
+        const Point &getPosition() const { return mPos; }
+        void setPosition(const Point &p) { mPos = p; }
+
+        /** Add a guild to the character */
+        void addGuild(const std::string &name) { mGuilds.push_back(name); }
+
+        /** Returns a list of guilds the player belongs to */
+        std::vector<std::string>
+        getGuilds() const { return mGuilds; }
+
+        /**
+         * Gets a reference on the possessions.
+         */
+        const Possessions &getPossessions() const
+        { return mPossessions; }
+
+        /**
+         * Gets a reference on the possessions.
+         */
+        Possessions &getPossessions()
+        { return mPossessions; }
+
+        void setCharacterPoints(int points)
+        { mCharacterPoints = points; }
+
+        int getCharacterPoints() const
+        { return mCharacterPoints; }
+
+        void setCorrectionPoints(int points)
+        { mCorrectionPoints = points; }
+
+        int getCorrectionPoints() const
+        { return mCorrectionPoints; }
+
+
+    private:
+
+        Character(const Character &);
+        Character &operator=(const Character &);
+
+        double getAttrBase(AttributeMap::const_iterator &it) const
+        { return it->second.first; }
+        double getAttrMod(AttributeMap::const_iterator &it) const
+        { return it->second.second; }
+
+        Possessions mPossessions; //!< All the possesions of the character.
+        std::string mName;        //!< Name of the character.
+        int mDatabaseID;          //!< Character database ID.
+        int mAccountID;           //!< Account ID of the owner.
+        Account *mAccount;        //!< Account owning the character.
+        Point mPos;               //!< Position the being is at.
+        /**
+         * Stores attributes.
+         * The key is an unsigned int which is the id of the attribute.
+         * The value stores the base value of the attribute in the first part,
+         * and the modified value in the second. The modified value is only
+         * used when transmitting to the client.
+         */
+        AttributeMap mAttributes; //!< Attributes.
+        std::map<int, int> mExperience; //!< Skill Experience.
+        std::map<int, int> mStatusEffects; //!< Status Effects
+        std::map<int, int> mKillCount; //!< Kill Count
+        std::map<int, Special*>  mSpecials;
+        unsigned short mMapId;    //!< Map the being is on.
+        unsigned char mGender;    //!< Gender of the being.
+        unsigned char mHairStyle; //!< Hair style of the being.
+        unsigned char mHairColor; //!< Hair color of the being.
+        short mLevel;             //!< Level of the being.
+        short mCharacterPoints;   //!< Unused character points.
+        short mCorrectionPoints;  //!< Unused correction points.
+        unsigned char mAccountLevel; //!< Level of the associated account.
+
+        std::vector<std::string> mGuilds;        //!< All the guilds the player
+                                                 //!< belongs to.
+        friend class AccountHandler;
+        friend class Storage;
+        // Set as a friend, but still a lot of redundant accessors. FIXME.
+        template< class T >
+        friend void serializeCharacterData(const T &data, MessageOut &msg);
+};
+
+/**
+ * Type definition for a list of Characters.
+ */
+typedef std::vector< Character * > Characters;
+
+#endif