Changed guilds to use character id.

9 files changed, 168 insertions, 187 deletions

diff --git a/src/account-server/dalstorage.cpp b/src/account-server/dalstorage.cpp
index 42a35467..cae4bcec 100644
--- a/src/account-server/dalstorage.cpp
+++ b/src/account-server/dalstorage.cpp
@@ -391,17 +391,12 @@ Character *DALStorage::getCharacter(int id, Account *owner)
     return getCharacterBySQL(sql.str(), owner);
 }
 
-/**
- * Gets a character by character name.
- */
 Character *DALStorage::getCharacter(const std::string &name)
 {
     std::ostringstream sql;
-    sql << "select * from " << CHARACTERS_TBL_NAME << " where name = \"" << name << "\";";
+    sql << "select * from " << CHARACTERS_TBL_NAME << " where name = '" << name << "';";
     return getCharacterBySQL(sql.str(), NULL);
 }
-
-
 #if 0
 /**
  * Return the list of all Emails addresses.
@@ -908,17 +903,17 @@ void DALStorage::removeGuild(Guild* guild)
 /**
  * add a member to a guild
  */
-void DALStorage::addGuildMember(int guildId, const std::string &memberName)
+void DALStorage::addGuildMember(int guildId, int memberId)
 {
     std::ostringstream sql;
 
     try
     {
         sql << "insert into " << GUILD_MEMBERS_TBL_NAME
-        << " (guild_id, member_name, rights)"
+        << " (guild_id, member_id, rights)"
         << " values ("
         << guildId << ", \""
-        << memberName << "\", "
+        << memberId << "\", "
         << 0 << ");";
         mDb->execSql(sql.str());
     }
@@ -931,15 +926,15 @@ void DALStorage::addGuildMember(int guildId, const std::string &memberName)
 /**
 * remove a member from a guild
  */
-void DALStorage::removeGuildMember(int guildId, const std::string &memberName)
+void DALStorage::removeGuildMember(int guildId, int memberId)
 {
     std::ostringstream sql;
 
     try
     {
         sql << "delete from " << GUILD_MEMBERS_TBL_NAME
-        << " where member_name = \""
-        << memberName << "\" and guild_id = '"
+        << " where member_id = \""
+        << memberId << "\" and guild_id = '"
         << guildId << "';";
         mDb->execSql(sql.str());
     }
@@ -950,7 +945,7 @@ void DALStorage::removeGuildMember(int guildId, const std::string &memberName)
     }
 }
 
-void DALStorage::setMemberRights(const std::string &memberName, int rights)
+void DALStorage::setMemberRights(int memberId, int rights)
 {
     std::ostringstream sql;
 
@@ -958,8 +953,8 @@ void DALStorage::setMemberRights(const std::string &memberName, int rights)
     {
         sql << "update " << GUILD_MEMBERS_TBL_NAME
         << " set rights = '" << rights << "'"
-        << " where member_name = \""
-        << memberName << "\";";
+        << " where member_id = \""
+        << memberId << "\";";
     }
     catch (const dal::DbSqlQueryExecFailure& e)
     {
@@ -1009,25 +1004,25 @@ std::list<Guild*> DALStorage::getGuildList()
              ++itr)
         {
             std::ostringstream memberSql;
-            memberSql << "select member_name, rights from " << GUILD_MEMBERS_TBL_NAME
+            memberSql << "select member_id, rights from " << GUILD_MEMBERS_TBL_NAME
             << " where guild_id = '" << (*itr)->getId() << "';";
             const dal::RecordSet& memberInfo = mDb->execSql(memberSql.str());
 
-            std::list<std::pair<std::string, int> > names;
+            std::list<std::pair<int, int> > members;
             for (unsigned int j = 0; j < memberInfo.rows(); ++j)
             {
-	      names.push_back(std::pair<std::string, int>(memberInfo(j, 0), toUint(memberInfo(j, 1))));
+	      members.push_back(std::pair<int, int>(toUint(memberInfo(j, 0)), toUint(memberInfo(j, 1))));
             }
 
-            for (std::list<std::pair<std::string, int> >::const_iterator i = names.begin();
-                 i != names.end();
+            for (std::list<std::pair<int, int> >::const_iterator i = members.begin();
+                 i != members.end();
                  ++i)
             {
-                Character *character = getCharacter((*i).first);
+                Character *character = getCharacter((*i).first, NULL);
                 if (character)
                 {
                     character->addGuild((*itr)->getName());
-                    (*itr)->addMember(character->getName(), (*i).second);
+                    (*itr)->addMember(character->getDatabaseID(), (*i).second);
                 }
             }
         }
diff --git a/src/account-server/dalstorage.hpp b/src/account-server/dalstorage.hpp
index 14222473..607b8187 100644
--- a/src/account-server/dalstorage.hpp
+++ b/src/account-server/dalstorage.hpp
@@ -172,19 +172,19 @@ class DALStorage
          *
          */
         void
-        addGuildMember(int guild_id, const std::string &memberName);
+        addGuildMember(int guild_id, int memberId);
 
         /**
          * Remove member from guild
          */
         void
-        removeGuildMember(int guildId, const std::string &memberName);
+        removeGuildMember(int guildId, int memberId);
 
         /**
          * Save guild member rights
          */
         void
-        setMemberRights(const std::string &memberName, int rights);
+        setMemberRights(int memberId, int rights);
 
         /**
          * Get guild list
diff --git a/src/account-server/dalstoragesql.hpp b/src/account-server/dalstoragesql.hpp
index 83062838..e485f6f9 100644
--- a/src/account-server/dalstoragesql.hpp
+++ b/src/account-server/dalstoragesql.hpp
@@ -75,6 +75,7 @@ static char const *SQL_ACCOUNTS_TABLE =
         "email    VARCHAR(64) NOT NULL,"
         "level    TINYINT     UNSIGNED NOT NULL,"
         "banned   TINYINT     UNSIGNED NOT NULL,"
+//        "activation VARCHAR(32),"
         "INDEX (id)"
 #error "Incorrect definition. Please fix the types."
 #elif defined (SQLITE_SUPPORT)
@@ -84,13 +85,15 @@ static char const *SQL_ACCOUNTS_TABLE =
         "email    TEXT        NOT NULL,"
         "level    INTEGER     NOT NULL,"
         "banned   INTEGER     NOT NULL"
+//        "activation TEXT"
 #elif defined (POSTGRESQL_SUPPORT)
         "id       SERIAL      PRIMARY KEY,"
         "username TEXT        NOT NULL UNIQUE,"
         "password TEXT        NOT NULL,"
         "email    TEXT        NOT NULL,"
         "level    INTEGER     NOT NULL,"
-        "banned   INTEGER     NOT NULL"
+        "banned   INTEGER     NOT NULL,"
+//        "activation TEXT"
 #endif
     ");";
 
@@ -261,16 +264,13 @@ static char const *SQL_GUILDS_TABLE =
     "CREATE TABLE tmw_guilds ("
 #if defined (MYSQL_SUPPORT)
         "id            INTEGER     PRIMARY KEY AUTO_INCREMENT,"
-        "name          VARCHAR(32) NOT NULL UNIQUE,"
-        "FOREIGN KEY (name) REFERENCES tmw_characters(name)"
+        "name          VARCHAR(32) NOT NULL UNIQUE"
 #elif defined (SQLITE_SUPPORT)
         "id      INTEGER     PRIMARY KEY,"
-        "name    TEXT        NOT NULL UNIQUE,"
-        "FOREIGN KEY (name) REFERENCES tmw_characters(name)"
+        "name    TEXT        NOT NULL UNIQUE"
 #elif defined (POSTGRESQL_SUPPORT)
         "id      SERIAL      PRIMARY KEY,"
-        "name    TEXT        NOT NULL UNIQUE,"
-        "FOREIGN KEY (name) REFERENCES tmw_characters(name)"
+        "name    TEXT        NOT NULL UNIQUE"
 #endif
     ");";
 
@@ -282,23 +282,23 @@ static char const *GUILD_MEMBERS_TBL_NAME = "tmw_guild_members";
 static char const *SQL_GUILD_MEMBERS_TABLE =
     "CREATE TABLE tmw_guild_members ("
 #if defined (MYSQL_SUPPORT)
-        "guild_id       INTEGER         NOT NULL,"
-        "member_name    VARCHAR(32)     NOT NULL,"
-        "rights         INTEGER         NOT NULL,"
+        "guild_id       INTEGER     NOT NULL,"
+        "member_id      INTEGER     NOT NULL,"
+        "rights         INTEGER     NOT NULL,"
         "FOREIGN KEY (guild_id)    REFERENCES tmw_guilds(id),"
-        "FOREIGN KEY (member_name) REFERENCES tmw_characters(name)"
+        "FOREIGN KEY (member_id)   REFERENCES tmw_characters(id)"
 #elif defined (SQLITE_SUPPORT)
         "guild_id       INTEGER     NOT NULL,"
-        "member_name    TEXT        NOT NULL,"
+        "member_id      INTEGER     NOT NULL,"
         "rights         INTEGER     NOT NULL,"
         "FOREIGN KEY (guild_id)    REFERENCES tmw_guilds(id),"
-        "FOREIGN KEY (member_name) REFERENCES tmw_characters(name)"
+        "FOREIGN KEY (member_id)   REFERENCES tmw_characters(id)"
 #elif defined (POSTGRESQL_SUPPORT)
         "guild_id       INTEGER     NOT NULL,"
-        "member_name    TEXT        NOT NULL,"
+        "member_id      INTEGER     NOT NULL,"
         "rights         INTEGER     NOT NULL,"
         "FOREIGN KEY (guild_id)    REFERENCES tmw_guilds(id),"
-        "FOREIGN KEY (member_name) REFERENCES tmw_characters(name)"
+        "FOREIGN KEY (member_id)   REFERENCES tmw_characters(id)"
 #endif
     ");";
 
diff --git a/src/chat-server/chatclient.hpp b/src/chat-server/chatclient.hpp
index 162e88d1..e2130a4c 100644
--- a/src/chat-server/chatclient.hpp
+++ b/src/chat-server/chatclient.hpp
@@ -52,6 +52,7 @@ class ChatClient : public NetComputer
         }
 
         std::string characterName;
+        unsigned int characterId;
         std::vector< ChatChannel * > channels;
         Party* party;
         unsigned char accountLevel;
diff --git a/src/chat-server/chathandler.cpp b/src/chat-server/chathandler.cpp
index d19aa8cf..f6f12a12 100644
--- a/src/chat-server/chathandler.cpp
+++ b/src/chat-server/chathandler.cpp
@@ -27,6 +27,7 @@
 #include <sstream>
 
 #include "defines.h"
+#include "account-server/character.hpp"
 #include "account-server/dalstorage.hpp"
 #include "account-server/serverhandler.hpp"
 #include "chat-server/guild.hpp"
@@ -84,17 +85,19 @@ void ChatHandler::deletePendingConnect(Pending *p)
     delete p;
 }
 
-void ChatHandler::tokenMatched(ChatClient *c, Pending *p)
+void ChatHandler::tokenMatched(ChatClient *client, Pending *p)
 {
-    c->characterName = p->character;
-    c->accountLevel = p->level;
+    client->characterName = p->character;
+    client->accountLevel = p->level;
+    Character *c = storage->getCharacter(p->character);
+    client->characterId = c->getDatabaseID();
     delete p;
     MessageOut msg(CPMSG_CONNECT_RESPONSE);
     msg.writeByte(ERRMSG_OK);
-    c->send(msg);
+    client->send(msg);
 
     // Add chat client to player map
-    mPlayerMap.insert(std::pair<std::string, ChatClient*>(c->characterName, c));
+    mPlayerMap.insert(std::pair<std::string, ChatClient*>(client->characterName, client));
 }
 
 NetComputer *ChatHandler::computerConnected(ENetPeer *peer)
@@ -549,9 +552,12 @@ ChatHandler::handleTopicChange(ChatClient &client, MessageIn &msg)
     else
     {
         Guild *guild = guildManager->findByName(channel->getName());
-        if(guild->checkLeader(client.characterName))
+        if (guild)
         {
-            chatChannelManager->setChannelTopic(channelId, topic);
+            if(guild->checkLeader(client.characterId))
+            {
+                chatChannelManager->setChannelTopic(channelId, topic);
+            }
         }
     }
 }
@@ -576,11 +582,11 @@ ChatHandler::handleGuildCreation(ChatClient &client, MessageIn &msg)
     if (!guildManager->doesExist(guildName))
     {
         // Guild doesnt already exist so create it
-        Guild *guild = guildManager->createGuild(guildName, client.characterName);
+        Guild *guild = guildManager->createGuild(guildName, client.characterId);
         reply.writeByte(ERRMSG_OK);
         reply.writeString(guildName);
         reply.writeShort(guild->getId());
-        reply.writeByte(true);
+        reply.writeShort(guild->getUserPermissions(client.characterId));
 
         // Send autocreated channel id
         ChatChannel* channel = joinGuildChannel(guildName, client);
@@ -612,9 +618,9 @@ ChatHandler::handleGuildInvitation(ChatClient &client, MessageIn &msg)
     {
         // check permissions of inviter, and that they arent inviting themself,
         // and arent someone already in the guild
-        if (guild->canInvite(client.characterName) &&
+        if (guild->canInvite(client.characterId) &&
             (client.characterName != character) &&
-            !guild->checkInGuild(character))
+            !guild->checkInGuild(invitedClient->characterId))
         {
             // send the name of the inviter and the name of the guild
             // that the character has been invited to join
@@ -627,7 +633,7 @@ ChatHandler::handleGuildInvitation(ChatClient &client, MessageIn &msg)
             reply.writeByte(ERRMSG_OK);
 
             // add member to list of invited members to the guild
-            guild->addInvited(character);
+            guild->addInvited(invitedClient->characterId);
         }
         else
         {
@@ -647,6 +653,7 @@ ChatHandler::handleGuildAcceptInvite(ChatClient &client, MessageIn &msg)
 {
     MessageOut reply(CPMSG_GUILD_ACCEPT_RESPONSE);
     std::string guildName = msg.readString();
+    bool error = true; // set true by default, and set false only if success
 
     // check guild exists and that member was invited
     // then add them as guild member
@@ -654,24 +661,26 @@ ChatHandler::handleGuildAcceptInvite(ChatClient &client, MessageIn &msg)
     Guild *guild = guildManager->findByName(guildName);
     if (guild)
     {
-        if (guild->checkInvited(client.characterName))
+        if (guild->checkInvited(client.characterId))
         {
-            guildManager->addGuildMember(guild, client.characterName);
+            // add user to guild
+            guildManager->addGuildMember(guild, client.characterId);
             reply.writeByte(ERRMSG_OK);
             reply.writeString(guild->getName());
             reply.writeShort(guild->getId());
-            reply.writeByte(false);
+            reply.writeShort(guild->getUserPermissions(client.characterId));
 
+            // have character join guild channel
             ChatChannel *channel = joinGuildChannel(guild->getName(), client);
             reply.writeShort(channel->getId());
             sendGuildListUpdate(guildName, client.characterName, GUILD_EVENT_NEW_PLAYER);
-        }
-        else
-        {
-            reply.writeByte(ERRMSG_FAILURE);
+
+            // success! set error to false
+            error = false;
         }
     }
-    else
+
+    if (error)
     {
         reply.writeByte(ERRMSG_FAILURE);
     }
@@ -691,7 +700,7 @@ ChatHandler::handleGuildRetrieveMembers(ChatClient &client, MessageIn &msg)
     if (guild)
     {
         // make sure the requestor is in the guild
-        if (guild->checkInGuild(client.characterName))
+        if (guild->checkInGuild(client.characterId))
         {
             reply.writeByte(ERRMSG_OK);
             reply.writeShort(guildId);
@@ -700,8 +709,10 @@ ChatHandler::handleGuildRetrieveMembers(ChatClient &client, MessageIn &msg)
             for(std::list<GuildMember*>::iterator itr = memberList.begin();
                 itr != itr_end; ++itr)
             {
-                reply.writeString((*itr)->getName());
-                reply.writeByte(mPlayerMap.find((*itr)->getName()) != mPlayerMap.end());
+                Character *c = storage->getCharacter((*itr)->mId, NULL);
+                std::string memberName = c->getName();
+                reply.writeString(memberName);
+                reply.writeByte(mPlayerMap.find(memberName) != mPlayerMap.end());
             }
         }
     }
@@ -716,15 +727,18 @@ ChatHandler::handleGuildRetrieveMembers(ChatClient &client, MessageIn &msg)
 void
 ChatHandler::handleGuildMemberLevelChange(ChatClient &client, MessageIn &msg)
 {
+    // get the guild, the user to change the permissions, and the new permission
+    // check theyre valid, and then change them
     MessageOut reply(CPMSG_GUILD_PROMOTE_MEMBER_RESPONSE);
     short guildId = msg.readShort();
     std::string user = msg.readString();
     short level = msg.readByte();
     Guild *guild = guildManager->findById(guildId);
+    Character *c = storage->getCharacter(user);
 
-    if (guild)
+    if (guild && c)
     {
-        if (guildManager->changeMemberLevel(&client, guild, user, level) == 0)
+        if (guildManager->changeMemberLevel(&client, guild, c->getDatabaseID(), level) == 0)
         {
             reply.writeByte(ERRMSG_OK);
             client.send(reply);
@@ -747,13 +761,13 @@ ChatHandler::handleGuildQuit(ChatClient &client, MessageIn &msg)
     // remove the member from the guild
     if (guild)
     {
-        if (guild->checkInGuild(client.characterName))
+        if (guild->checkInGuild(client.characterId))
         {
             reply.writeByte(ERRMSG_OK);
             reply.writeShort(guildId);
 
             // Check if they are the leader, and if so, remove the guild channel
-            if (guild->checkLeader(client.characterName))
+            if (guild->checkLeader(client.characterId))
             {
                 chatChannelManager->removeChannel(chatChannelManager->getChannelId(guild->getName()));
             }
@@ -761,7 +775,7 @@ ChatHandler::handleGuildQuit(ChatClient &client, MessageIn &msg)
             {
                 // guild manager checks if the member is the last in the guild
                 // and removes the guild if so
-                guildManager->removeGuildMember(guild, client.characterName);
+                guildManager->removeGuildMember(guild, client.characterId);
                 sendGuildListUpdate(guild->getName(), client.characterName, GUILD_EVENT_LEAVING_PLAYER);
             }
         }
@@ -839,7 +853,7 @@ void ChatHandler::sendGuildInvite(const std::string &invitedName,
 void ChatHandler::sendGuildRejoin(ChatClient &client)
 {
     // Get list of guilds and check what rights they have.
-    std::vector<Guild*> guilds = guildManager->getGuildsForPlayer(client.characterName);
+    std::vector<Guild*> guilds = guildManager->getGuildsForPlayer(client.characterId);
     for (unsigned int i = 0; i != guilds.size(); ++i)
     {
         Guild *guild = guilds[i];
@@ -848,7 +862,7 @@ void ChatHandler::sendGuildRejoin(ChatClient &client)
         {
             return;
         }
-        permissions = guild->getUserPermissions(client.characterName);
+        permissions = guild->getUserPermissions(client.characterId);
 
         std::string guildName = guild->getName();
 
@@ -914,7 +928,8 @@ void ChatHandler::sendGuildListUpdate(const std::string &guildName,
         for (std::list<GuildMember*>::const_iterator itr = members.begin();
              itr != members.end(); ++itr)
         {
-            chr = mPlayerMap.find((*itr)->getName());
+            Character *c = storage->getCharacter((*itr)->mId, NULL);
+            chr = mPlayerMap.find(c->getName());
             if (chr != mPlayerMap.end())
             {
                 chr->second->send(msg);
diff --git a/src/chat-server/guild.cpp b/src/chat-server/guild.cpp
index 980c34c4..6e584ebd 100644
--- a/src/chat-server/guild.cpp
+++ b/src/chat-server/guild.cpp
@@ -24,22 +24,6 @@
 
 #include <algorithm>
 
-GuildMember::GuildMember(const std::string &name) :
-    mName(name),
-    mPermissions(0)
-{
-}
-
-void GuildMember::setPermission(int perm)
-{
-    mPermissions = perm;
-}
-
-int GuildMember::getPermissions() const
-{
-    return mPermissions;
-}
-
 Guild::Guild(const std::string &name) :
 mName(name)
 {
@@ -49,68 +33,74 @@ Guild::~Guild()
 {
 }
 
-void Guild::addMember(const std::string &playerName, int permissions)
+void Guild::addMember(int playerId, int permissions)
 {
-    GuildMember *member = new GuildMember(playerName);
-    member->setPermission(permissions);
+    // create new guild member
+    GuildMember *member = new GuildMember();
+    member->mId = playerId;
+    member->mPermissions = permissions;
+
+    // add new guild member to guild
     mMembers.push_back(member);
-    if (checkInvited(playerName))
+
+    if (checkInvited(playerId))
     {
-        mInvited.remove(playerName);
+        mInvited.remove(playerId);
     }
 }
 
-void Guild::removeMember(const std::string &playerName)
+void Guild::removeMember(int playerId)
 {
-    GuildMember *member = getMember(playerName);
+    GuildMember *member = getMember(playerId);
     if (member)
         mMembers.remove(member);
 }
 
-bool Guild::checkLeader(const std::string &playerName)
+bool Guild::checkLeader(int playerId)
 {
-    // check that guild member permissions is set to LEADER
     int leader = 0;
-    GuildMember *member = getMember(playerName);
+    GuildMember *member = getMember(playerId);
+    // check member exists
     if (member)
-        leader = member->getPermissions();
+        leader = member->mPermissions;
+    // check permissions
     if (leader == GuildMember::LEADER)
         return true;
     return false;
 
 }
 
-void Guild::setLeader(const std::string &playerName)
+void Guild::setLeader(int playerId)
 {
-    GuildMember *member = getMember(playerName);
+    GuildMember *member = getMember(playerId);
     if (member)
     {
-        member->setPermission(GuildMember::LEADER);
+        member->mPermissions = GuildMember::LEADER;
     }
 }
 
-bool Guild::checkInvited(const std::string &playerName)
+bool Guild::checkInvited(int playerId)
 {
-    return std::find(mInvited.begin(), mInvited.end(), playerName) != mInvited.end();
+    return std::find(mInvited.begin(), mInvited.end(), playerId) != mInvited.end();
 }
 
-void Guild::addInvited(const std::string &playerName)
+void Guild::addInvited(int playerId)
 {
-    mInvited.push_back(playerName);
+    mInvited.push_back(playerId);
 }
 
-bool Guild::checkInGuild(const std::string &playerName)
+bool Guild::checkInGuild(int playerId)
 {
-    GuildMember *member = getMember(playerName);
+    GuildMember *member = getMember(playerId);
     return member ? true : false;
 }
 
-GuildMember* Guild::getMember(const std::string &playerName)
+GuildMember* Guild::getMember(int playerId)
 {
     std::list<GuildMember*>::iterator itr = mMembers.begin(), itr_end = mMembers.end();
     while (itr != itr_end)
     {
-        if ((*itr)->getName() == playerName)
+        if ((*itr)->mId == playerId)
         {
             return (*itr);
         }
@@ -121,24 +111,24 @@ GuildMember* Guild::getMember(const std::string &playerName)
     return NULL;
 }
 
-bool Guild::canInvite(const std::string &playerName)
+bool Guild::canInvite(int playerId)
 {
     // Guild members with permissions above NONE can invite
     // Check that guild members permissions are not NONE
-    GuildMember *member = getMember(playerName);
-    if (member->getPermissions() > GuildMember::NONE)
+    GuildMember *member = getMember(playerId);
+    if (member->mPermissions > GuildMember::NONE)
         return true;
     return false;
 }
 
-int Guild::getUserPermissions(const std::string &playerName)
+int Guild::getUserPermissions(int playerId)
 {
-    GuildMember *member = getMember(playerName);
-    return member->getPermissions();
+    GuildMember *member = getMember(playerId);
+    return member->mPermissions;
 }
 
-void Guild::setUserPermissions(const std::string &playerName, int level)
+void Guild::setUserPermissions(int playerId, int level)
 {
-    GuildMember *member = getMember(playerName);
-    member->setPermission(level);
+    GuildMember *member = getMember(playerId);
+    member->mPermissions = level;
 }
diff --git a/src/chat-server/guild.hpp b/src/chat-server/guild.hpp
index 050dc17f..c46a0657 100644
--- a/src/chat-server/guild.hpp
+++ b/src/chat-server/guild.hpp
@@ -30,42 +30,21 @@
  * Guild members
  */
 
-class GuildMember
+struct GuildMember
 {
-    public:
-        /**
-         * Permissions
-         * Members with NONE cannot invite users or set permissions
-         * Members with COMMANDER can invite other users but
-         *  cannot set permissions
-         * Members with LEADER can invite users and set permissions
-         */
-        enum { NONE = 0, COMMANDER, LEADER };
-
-        /**
-         * Constructor
-         */
-        GuildMember(const std::string &name);
-
-        /**
-         * Get name
-         */
-        const std::string& getName() const
-        { return mName; }
-
-        /**
-         * Set permissions
-         */
-        void setPermission(int perm);
-
-        /**
-         * Get permissions
-         */
-        int getPermissions() const;
-
-    private:
-        std::string mName;
-        int mPermissions;
+public:
+    /**
+     * Permissions
+     * Members with NONE cannot invite users or set permissions
+     * Members with COMMANDER can invite other users but
+     *  cannot set permissions
+     * Members with LEADER can invite users and set permissions
+     */
+    enum { NONE = 0, COMMANDER, LEADER };
+
+    int mId;
+    std::string mName;
+    int mPermissions;
 
 };
 
@@ -87,23 +66,24 @@ class Guild
 
         /**
          * Add a member to the guild.
+         * Removes a user from invite list if on it
          */
-        void addMember(const std::string &playerName, int permissions = GuildMember::NONE);
+        void addMember(int playerId, int permissions = GuildMember::NONE);
 
         /**
          * Remove a member from the guild.
          */
-        void removeMember(const std::string &playerName);
+        void removeMember(int playerId);
 
         /**
          * Check player is the leader of the guild.
          */
-        bool checkLeader(const std::string &playerName);
+        bool checkLeader(int playerId);
 
         /**
          * Set player as leader of the guild.
          */
-        void setLeader(const std::string &playerName);
+        void setLeader(int playerId);
 
         /**
          * Set the ID of the guild.
@@ -114,12 +94,12 @@ class Guild
         /**
          * Check if player has been invited to the guild.
          */
-        bool checkInvited(const std::string &playerName);
+        bool checkInvited(int playerId);
 
         /**
          * Add a player to the invite list.
          */
-        void addInvited(const std::string &playerName);
+        void addInvited(int playerId);
 
         /**
          * Returns the name of the guild.
@@ -148,34 +128,34 @@ class Guild
         /**
          * Find member by name.
          */
-        bool checkInGuild(const std::string &playerName);
+        bool checkInGuild(int playerId);
 
         /**
          * Returns whether a user can invite
          */
-        bool canInvite(const std::string &name);
+        bool canInvite(int playerId);
 
         /**
          * Returns a users permissions
          */
-        int getUserPermissions(const std::string &name);
+        int getUserPermissions(int playerId);
 
         /**
          * Sets a users permissions
          */
-        void setUserPermissions(const std::string &playerName, int level);
+        void setUserPermissions(int playerId, int level);
 
     protected:
         /**
          * Return a member based on their character name
          */
-        GuildMember* getMember(const std::string &playerName);
+        GuildMember* getMember(int playerId);
 
     private:
         short mId;
         std::string mName;
         std::list<GuildMember*> mMembers;
-        std::list<std::string> mInvited;
+        std::list<int> mInvited;
 };
 
 #endif
diff --git a/src/chat-server/guildmanager.cpp b/src/chat-server/guildmanager.cpp
index 4976eca5..4d51ca1c 100644
--- a/src/chat-server/guildmanager.cpp
+++ b/src/chat-server/guildmanager.cpp
@@ -43,7 +43,7 @@ GuildManager::~GuildManager()
     mGuilds.clear();
 }
 
-Guild* GuildManager::createGuild(const std::string &name, const std::string &playerName)
+Guild* GuildManager::createGuild(const std::string &name, int playerId)
 {
     Guild *guild = new Guild(name);
     // Add guild to db
@@ -52,12 +52,12 @@ Guild* GuildManager::createGuild(const std::string &name, const std::string &pla
     // Make sure to add guild to mGuilds before searching for it to add the
     // player
     mGuilds.push_back(guild);
-    addGuildMember(guild, playerName);
+    addGuildMember(guild, playerId);
 
     // Set and save the member rights
-    storage->setMemberRights(playerName, GuildMember::LEADER);
+    storage->setMemberRights(playerId, GuildMember::LEADER);
 
-    guild->setLeader(playerName);
+    guild->setLeader(playerId);
 
     return guild;
 }
@@ -71,20 +71,20 @@ void GuildManager::removeGuild(Guild *guild)
     delete guild;
 }
 
-void GuildManager::addGuildMember(Guild *guild, const std::string &playerName)
+void GuildManager::addGuildMember(Guild *guild, int playerId)
 {
     if (!guild)
         return;
-    storage->addGuildMember(guild->getId(), playerName);
-    guild->addMember(playerName);
+    storage->addGuildMember(guild->getId(), playerId);
+    guild->addMember(playerId);
 }
 
-void GuildManager::removeGuildMember(Guild *guild, const std::string &playerName)
+void GuildManager::removeGuildMember(Guild *guild, int playerId)
 {
     if (!guild)
         return;
-    storage->removeGuildMember(guild->getId(), playerName);
-    guild->removeMember(playerName);
+    storage->removeGuildMember(guild->getId(), playerId);
+    guild->removeMember(playerId);
     if(guild->totalMembers() == 0)
     {
         removeGuild(guild);
@@ -128,14 +128,14 @@ bool GuildManager::doesExist(const std::string &name)
     return findByName(name) != NULL;
 }
 
-std::vector<Guild*> GuildManager::getGuildsForPlayer(const std::string &name)
+std::vector<Guild*> GuildManager::getGuildsForPlayer(int playerId)
 {
     std::vector<Guild*> guildList;
 
     for (std::list<Guild*>::iterator itr = mGuilds.begin();
             itr != mGuilds.end(); ++itr)
     {
-        if((*itr)->checkInGuild(name))
+        if((*itr)->checkInGuild(playerId))
         {
             guildList.push_back((*itr));
         }
@@ -145,7 +145,7 @@ std::vector<Guild*> GuildManager::getGuildsForPlayer(const std::string &name)
 
 void GuildManager::disconnectPlayer(ChatClient *player)
 {
-    std::vector<Guild*> guildList = getGuildsForPlayer(player->characterName);
+    std::vector<Guild*> guildList = getGuildsForPlayer(player->characterId);
 
     for (std::vector<Guild*>::const_iterator itr = guildList.begin();
          itr != guildList.end(); ++itr)
@@ -157,16 +157,16 @@ void GuildManager::disconnectPlayer(ChatClient *player)
 }
 
 int GuildManager::changeMemberLevel(ChatClient *player, Guild *guild,
-                                     const std::string &name, int level)
+                                    int playerId, int level)
 {
-    if (guild->checkInGuild(player->characterName) && guild->checkInGuild(name))
+    if (guild->checkInGuild(player->characterId) && guild->checkInGuild(playerId))
     {
-        int playerLevel = guild->getUserPermissions(player->characterName);
+        int playerLevel = guild->getUserPermissions(player->characterId);
 
         if (playerLevel == GuildMember::LEADER)
         {
             // player can modify anyones permissions
-            guild->setUserPermissions(name, level);
+            guild->setUserPermissions(playerId, level);
             return 0;
         }
     }
diff --git a/src/chat-server/guildmanager.hpp b/src/chat-server/guildmanager.hpp
index 7dd03b42..008d1910 100644
--- a/src/chat-server/guildmanager.hpp
+++ b/src/chat-server/guildmanager.hpp
@@ -48,7 +48,7 @@ class GuildManager
         /**
          * Creates a guild.
          */
-        Guild* createGuild(const std::string &name, const std::string &playerName);
+        Guild* createGuild(const std::string &name, int playerId);
 
         /**
          * Removes a guild.
@@ -58,12 +58,12 @@ class GuildManager
         /**
          * Adds a member to a guild.
          */
-        void addGuildMember(Guild *guild, const std::string &playerName);
+        void addGuildMember(Guild *guild, int playerId);
 
         /**
          * Removes a member from a guild.
          */
-        void removeGuildMember(Guild *guild, const std::string &playerName);
+        void removeGuildMember(Guild *guild, int playerId);
 
         /**
          * Returns the guild with the given id. O(n)
@@ -91,7 +91,7 @@ class GuildManager
         /**
          * Return the guilds a character is in
          */
-        std::vector<Guild*> getGuildsForPlayer(const std::string &name);
+        std::vector<Guild*> getGuildsForPlayer(int playerId);
 
         /**
          * Inform guild members that a player has disconnected.
@@ -105,7 +105,7 @@ class GuildManager
          * @return Returns 0 if successful, -1 otherwise
          */
         int changeMemberLevel(ChatClient *player, Guild *guild,
-                               const std::string &name, int level);
+                              int playerId, int level);
 
     private:
         std::list<Guild*> mGuilds;