char.cpp:

void CHARACTER::SendGuildName(CGuild* pGuild)
{
    if (NULL == pGuild) return;
    DESC* desc = GetDesc();
    if (NULL == desc) return;
    if (m_known_guild.find(pGuild->GetID()) != m_known_guild.end()) return;
    
    m_known_guild.insert(pGuild->GetID());
    TPacketGCGuildName pack;
    memset(&pack, 0x00, sizeof(pack));
    pack.header = HEADER_GC_GUILD;
    pack.subheader = GUILD_SUBHEADER_GC_GUILD_NAME;
    pack.size = sizeof(TPacketGCGuildName);
    pack.guildID = pGuild->GetID();
    memcpy(pack.guildName, pGuild->GetName(), GUILD_NAME_MAX_LEN);
    
    pack.guildLevel = pGuild->GetLevel();
    
    desc->Packet(&pack, sizeof(pack));
}

packet.h:

typedef struct packet_guild_name_t
{
    BYTE header;
    WORD size;
    BYTE subheader;
    DWORD guildID;
    char guildName[GUILD_NAME_MAX_LEN];
    
    int guildLevel;
    
} TPacketGCGuildName;

PythonGuild.h:

struct GuildNameLevel
{
    std::string name; 
    int level;        
};

typedef std::map<DWORD, GuildNameLevel> TGuildNameMap;

void RegisterGuildName(DWORD dwID, const char * c_szName, int level);


PythonGuild.cpp:

void CPythonGuild::RegisterGuildName(DWORD dwID, const char * c_szName, int level)
{
    GuildNameLevel gnr;
    gnr.name = std::string(c_szName);
    
    gnr.level = level;  
    m_GuildNameMap.insert(make_pair(dwID, gnr));
}

bool CPythonGuild::GetGuildName(DWORD dwID, std::string * pstrGuildName)
{
    if (m_GuildNameMap.end() == m_GuildNameMap.find(dwID))
        return false;

    int guildLevel = m_GuildNameMap[dwID].level; 
    
    if (guildLevel >= 10)
    {
        *pstrGuildName = "|cffFFC125" + m_GuildNameMap[dwID].name + "|r"; 
    }
    else if (guildLevel >= 5)
    {
        *pstrGuildName = "|cff888888" + m_GuildNameMap[dwID].name + "|r"; 
    }
    else if (guildLevel > 0)
    {
        *pstrGuildName = "|cffCD661D" + m_GuildNameMap[dwID].name + "|r"; 
    }
    else
    {
        *pstrGuildName = m_GuildNameMap[dwID].name; 
    }

    return true;
}

PythonNetworkStreamPhaseGame.cpp :

case GUILD_SUBHEADER_GC_GUILD_NAME:
{
    DWORD dwID;
    char szGuildName[GUILD_NAME_MAX_LEN + 1];
    int guildLevel; 

    int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
    int nItemSize = sizeof(dwID) + GUILD_NAME_MAX_LEN + sizeof(guildLevel);
    assert(iPacketSize % nItemSize == 0 && "GUILD_SUBHEADER_GC_GUILD_NAME");

    for (; iPacketSize > 0;)
    {
        if (!Recv(sizeof(dwID), &dwID))
            return false;

        if (!Recv(GUILD_NAME_MAX_LEN, &szGuildName))
            return false;

        if (!Recv(sizeof(guildLevel), &guildLevel)) 
            return false;

        szGuildName[GUILD_NAME_MAX_LEN] = 0;
        CPythonGuild::Instance().RegisterGuildName(dwID, szGuildName, guildLevel);
        iPacketSize -= nItemSize;
    }
    break;
}