Beispiel #1
0
void ChatLog::OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Group* group)
{
    std::string origMsg(msg);
    std::string logStr;
    _AppendPlayerName(player, logStr);

    switch (type)
    {
    case CHAT_MSG_PARTY:
    case CHAT_MSG_PARTY_LEADER:
        if (_ChatCommon(CHAT_LOG_PARTY, player, msg))
        {
            switch (type)
            {
                case CHAT_MSG_PARTY:        logStr.append("->PARTY");         break;
                case CHAT_MSG_PARTY_LEADER: logStr.append("->PARTY_LEADER");  break;
            }
            _AppendGroupMembers(group, logStr);
            _WriteLog(_logs[CHAT_LOG_PARTY], logStr, msg, origMsg);
        }
        break;
    case CHAT_MSG_RAID_LEADER:
    case CHAT_MSG_RAID_WARNING:
    case CHAT_MSG_RAID:
        if (_ChatCommon(CHAT_LOG_RAID, player, msg))
        {
            switch (type)
            {
                case CHAT_MSG_RAID_LEADER:  logStr.append("->RAID_LEADER");
                case CHAT_MSG_RAID_WARNING: logStr.append("->RAID_WARN");
                case CHAT_MSG_RAID:         logStr.append("->RAID");
            }
            _AppendGroupMembers(group, logStr);
            _WriteLog(_logs[CHAT_LOG_RAID], logStr, msg, origMsg);
        }
        break;
    case CHAT_MSG_BATTLEGROUND:
    case CHAT_MSG_BATTLEGROUND_LEADER:
        if (_ChatCommon(CHAT_LOG_BATTLEGROUND, player, msg))
        {
            switch (type)
            {
                case CHAT_MSG_BATTLEGROUND:         logStr.append("->BG");         break;
                case CHAT_MSG_BATTLEGROUND_LEADER:  logStr.append("->BG_LEADER");  break;
            }
            _AppendGroupMembers(group, logStr);
            _WriteLog(_logs[CHAT_LOG_BATTLEGROUND], logStr, msg, origMsg);
        }
        break;
    }
}
Beispiel #2
0
void ChatLog::OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Group* group)
{
    std::string origMsg(msg);
    std::ostringstream ss;
    _AppendPlayerName(player, ss);

    switch (type)
    {
    case CHAT_MSG_PARTY:
    case CHAT_MSG_PARTY_LEADER:
        if (_ChatCommon(CHAT_LOG_PARTY, player, msg))
        {
            switch (type)
            {
                case CHAT_MSG_PARTY:        ss << "->PARTY";        break;
                case CHAT_MSG_PARTY_LEADER: ss << "->PARTY_LEADER"; break;
            }
            _AppendGroupMembers(group, ss);
            _WriteLog(_logs[CHAT_LOG_PARTY], ss.str(), origMsg);
        }
        break;
    case CHAT_MSG_RAID_LEADER:
    case CHAT_MSG_RAID_WARNING:
    case CHAT_MSG_RAID:
        if (_ChatCommon(CHAT_LOG_RAID, player, msg))
        {
            switch (type)
            {
                case CHAT_MSG_RAID_LEADER:  ss << "->RAID_LEADER";  break;
                case CHAT_MSG_RAID_WARNING: ss << "->RAID_WARN";    break;
                case CHAT_MSG_RAID:         ss << "->RAID";         break;
            }
            _AppendGroupMembers(group, ss);
            _WriteLog(_logs[CHAT_LOG_RAID], ss.str(), origMsg);
        }
        break;
    case CHAT_MSG_BATTLEGROUND:
    case CHAT_MSG_BATTLEGROUND_LEADER:
        if (_ChatCommon(CHAT_LOG_BATTLEGROUND, player, msg))
        {
            switch (type)
            {
                case CHAT_MSG_BATTLEGROUND:         ss << "->BG";           break;
                case CHAT_MSG_BATTLEGROUND_LEADER:  ss << "->BG_LEADER";    break;
            }
            _AppendGroupMembers(group, ss);
            _WriteLog(_logs[CHAT_LOG_BATTLEGROUND], ss.str(), origMsg);
        }
        break;
    }
}
Beispiel #3
0
void ChatLog::OnChat(Player* player, uint32 /*type*/, uint32 /*lang*/, std::string& msg, Channel* channel)
{
    std::string origMsg(msg);
    if (!_ChatCommon(CHAT_LOG_CHANNEL, player, msg))
        return;

    std::ostringstream ss;
    _AppendPlayerName(player, ss);
    ss << " {" << (channel ? channel->GetName() : "Unknown channel") << "}";

    _WriteLog(_logs[CHAT_LOG_CHANNEL], ss.str(), origMsg);
}
Beispiel #4
0
void ChatLog::OnChat(Player* player, uint32 /*type*/, uint32 /*lang*/, std::string& msg, Channel* channel)
{
    std::string origMsg(msg);
    if (!_ChatCommon(CHAT_LOG_CHANNEL, player, msg))
        return;

    std::string logStr;
    _AppendPlayerName(player, logStr);
    logStr.append(" {").append(channel ? channel->GetName() : "Unknown channel").append("}");

    _WriteLog(_logs[CHAT_LOG_CHANNEL], logStr, msg, origMsg);
}
Beispiel #5
0
void ChatLog::OnChat(Player* player, uint32 /*type*/, uint32 /*lang*/, std::string& msg, Player* receiver)
{
    std::string origMsg(msg);
    if (!_ChatCommon(CHAT_LOG_WHISPER, player, msg))
        return;

    std::ostringstream ss;
    _AppendPlayerName(player, ss);
    ss << "->";
    _AppendPlayerName(receiver, ss);

    _WriteLog(_logs[CHAT_LOG_WHISPER], ss.str(), origMsg);
}
Beispiel #6
0
void ChatLog::OnChat(Player* player, uint32 /*type*/, uint32 /*lang*/, std::string& msg, Player* receiver)
{
    std::string origMsg(msg);
    if (!_ChatCommon(CHAT_LOG_WHISPER, player, msg))
        return;

    std::string logStr;
    _AppendPlayerName(player, logStr);
    logStr.append("->");
    _AppendPlayerName(receiver, logStr);

    _WriteLog(_logs[CHAT_LOG_WHISPER], logStr, msg, origMsg);
}
Beispiel #7
0
void ChatLog::OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg)
{
    std::string origMsg(msg);
    if (!_ChatCommon(CHAT_LOG_CHAT, player, msg))
        return;

    std::ostringstream ss;
    switch (type)
    {
        case CHAT_MSG_SAY:      ss << "{SAY}";      break;
        case CHAT_MSG_EMOTE:    ss << "{EMOTE}";    break;
        case CHAT_MSG_YELL:     ss << "{YELL}";     break;
    }
    _AppendPlayerName(player, ss);
    _WriteLog(_logs[CHAT_LOG_CHAT], ss.str(), origMsg);
}
Beispiel #8
0
void ChatLog::OnChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg)
{
    std::string origMsg(msg);
    if (!_ChatCommon(CHAT_LOG_CHAT, player, msg))
        return;

    std::string logStr;
    switch (type)
    {
        case CHAT_MSG_SAY: logStr.append("{SAY}"); break;
        case CHAT_MSG_EMOTE: logStr.append("{EMOTE}"); break;
        case CHAT_MSG_YELL: logStr.append("{YELL}"); break;
    }
    _AppendPlayerName(player, logStr);
    _WriteLog(_logs[CHAT_LOG_CHAT], logStr, msg, origMsg);
}
Beispiel #9
0
void ChatLog::OnChat(Player* player, uint32 type, uint32 lang, std::string& msg, Guild* guild)
{
    std::string origMsg(msg);
    if (!_ChatCommon(CHAT_LOG_GUILD, player, msg))
        return;

    std::ostringstream ss;
    _AppendPlayerName(player, ss);
    switch (type)
    {
        case CHAT_MSG_GUILD:    ss << "->GUILD";      break;
        case CHAT_MSG_OFFICER:  ss << "->GUILD_OFF";  break;
    }
    ss << " {" << (guild ? guild->GetName() : "unknowng guild") << "}:";

    _WriteLog(_logs[CHAT_LOG_GUILD], ss.str(), origMsg);
}
Beispiel #10
0
void ChatLog::OnChat(Player* player, uint32 type, uint32 lang, std::string& msg, Guild* guild)
{
    std::string origMsg(msg);
    if (!_ChatCommon(CHAT_LOG_GUILD, player, msg))
        return;

    std::string logStr;
    _AppendPlayerName(player, logStr);
    switch (type)
    {
        case CHAT_MSG_GUILD:    logStr.append("->GUILD");      break;
        case CHAT_MSG_OFFICER:  logStr.append("->GUILD_OFF");  break;
    }
    logStr.append(" {").append(guild ? guild->GetName() : "unknowng guild").append("}:");

    _WriteLog(_logs[CHAT_LOG_GUILD], logStr, msg, origMsg);
}
Beispiel #11
0
void ChatLog::_Punish(Player* player, std::string& msg)
{
    std::string logStr;

    _AppendPlayerName(player, logStr);
    _WriteLog(_innormativeLog, logStr, msg, msg);

    // Check if should ignore GM
    if (_lexicsIgnoreGm && (player->GetSession()->GetSecurity() > SEC_PLAYER))
        return;

    // Cut innormative lexics
    if (_lexicsInnormativeCut)
        msg = _lexicsCutReplacement;

    if (!player || !player->GetSession())
        return;

    // special action
    switch (_lexicsAction)
    {
        case LEXICS_ACTION_SHEEP:       
            _ApplySpell(player, 42365);
            player->GetSession()->m_muteTime = time(NULL) + int64(_lexicsActionDuration / 1000);
            break;
        case LEXICS_ACTION_STUN:        _ApplySpell(player, 13005); break;
        case LEXICS_ACTION_STUCK:       _ApplySpell(player, 23312); break;
        case LEXICS_ACTION_SICKNESS:    _ApplySpell(player, 15007); break;
        case LEXICS_ACTION_SHEAR:       _ApplySpell(player, 41032); break;
        case LEXICS_ACTION_DIE:
            player->DealDamage(player, player->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
            break;
        case LEXICS_ACTION_DRAIN:
            player->DealDamage(player, player->GetHealth() - 5, NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
            break;
        case LEXICS_ACTION_SILENCE:
            player->GetSession()->m_muteTime = time(NULL) + int64(_lexicsActionDuration / 1000);
            break;
        default:
            // No action except logging
            break;
    }
}