Ejemplo n.º 1
0
void ObjectAccessor::Update(uint32 /*diff*/)
{
    UpdateDataMapType update_players;

    while (!i_objects.empty())
    {
        Object* obj = *i_objects.begin();
        ASSERT(obj && obj->IsInWorld());
        i_objects.erase(i_objects.begin());
        obj->BuildUpdate(update_players);
    }

    WorldPacket packet;                                     // here we allocate a std::vector with a size of 0x10000
    for (UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
    {
        iter->second.BuildPacket(&packet);
        iter->first->GetSession()->SendPacket(&packet);
        packet.clear();                                     // clean the string
    }
}
Ejemplo n.º 2
0
void Channel::Leave(uint64 p, bool send)
{
    if (!IsOn(p))
    {
        if (send)
        {
            WorldPacket data;
            MakeNotMember(&data);
            SendToOne(&data, p);
        }
    }
    else
    {
        Player *plr = sObjectMgr.GetPlayer(p);

        if (send)
        {
            WorldPacket data;
            MakeYouLeft(&data);
            SendToOne(&data, p);
            if (plr)
                plr->LeftChannel(this);
            data.clear();
        }

        bool changeowner = players[p].IsOwner();

        players.erase(p);
        if (m_announce && (!plr || !plr->GetSession()->HasPermissions(PERM_GMT) || !sWorld.getConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
        {
            //WorldPacket data;
            //MakeLeft(&data, p);
            //SendToAll(&data);
        }

        LeaveNotify(p);

        if (changeowner)
            ChangeOwner();
    }
}
Ejemplo n.º 3
0
void Channel::Leave(uint64 p, bool send)
{
    if(!IsOn(p))
    {
        if(send)
        {
            WorldPacket data;
            MakeNotMember(&data);
            SendToOne(&data, p);
        }
    }
    else
    {
        if(send)
        {
            WorldPacket data;
            MakeYouLeft(&data);
            SendToOne(&data, p);
            Player *plr = objmgr.GetPlayer(p);
            if(plr)
                plr->LeftChannel(this);
            data.clear();
        }

        bool changeowner = players[p].IsOwner();

        players.erase(p);
        if(m_announce)
        {
            WorldPacket data;
            MakeLeft(&data, p);
            SendToAll(&data);
        }

        if(changeowner)
        {
            uint64 newowner = !players.empty() ? players.begin()->second.player : 0;
            SetOwner(newowner);
        }
    }
}
Ejemplo n.º 4
0
void Channel::Invite(uint64 p, const char *newname)
{
    if(!IsOn(p))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, p);
    }
    else
    {
        Player *newp = objmgr.GetPlayer(newname);
        if(!newp)
        {
            WorldPacket data;
            MakePlayerNotFound(&data, newname);
            SendToOne(&data, p);
        }
        else if(IsOn(newp->GetGUID()))
        {
            WorldPacket data;
            MakePlayerAlreadyMember(&data, newp->GetGUID());
            SendToOne(&data, p);
        }
        else
        {
            WorldPacket data;
            if(!newp->HasInIgnoreList(p))
            {
                MakeInvite(&data, p);
                SendToOne(&data, newp->GetGUID());
                data.clear();
            }
            MakePlayerInvited(&data, newp->GetGUID());
            SendToOne(&data, p);
        }
    }
}
Ejemplo n.º 5
0
void
ObjectAccessor::Update(uint32 diff)
{
    UpdateDataMapType update_players;
    {
        Guard guard(i_updateGuard);
        while(!i_objects.empty())
        {
            Object* obj = *i_objects.begin();
            assert(obj && obj->IsInWorld());
            i_objects.erase(i_objects.begin());
            _buildUpdateObject(obj, update_players);
            obj->ClearUpdateMask(false);
        }
    }

    WorldPacket packet;                                     // here we allocate a std::vector with a size of 0x10000
    for(UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
    {
        iter->second.BuildPacket(&packet);
        iter->first->GetSession()->SendPacket(&packet);
        packet.clear();                                     // clean the string
    }
}
Ejemplo n.º 6
0
void
World::ShuttingDownMsg()
{
	if(m_ShutdownTimer <= 0)
		raise(SIGINT);
	char msg[256];
	std::stringstream ss;
	WorldPacket data;

	sprintf((char*)msg, "[Server] Shutdown in %d seconds", m_ShutdownTimer);
	SendWorldWideText( msg );

	data.Initialize(SMSG_SERVER_MESSAGE);
	ss << m_ShutdownTimer << " Second(s).";
	data << uint32(1) << ss.str().c_str() << (uint8)0x00;
	SendGlobalMessage( &data );

	data.clear();
	ss.clear();

	sLog.outColor(3);
	sLog.outString("[Server] Shutdown in %d seconds...\n", m_ShutdownTimer);
	sLog.outColor(2);
}
Ejemplo n.º 7
0
void Channel::Join(uint64 p, const char *pass)
{
    WorldPacket data;
    
    std::string worldChatChannelName = sWorld->GetWorldChatChannelName();
    uint64 worldChatOwnerGuid = sWorld->GetWorldChatOwnerGuid();
    uint64 worldChatIdleGuid = sWorld->GetWorldChatIdleGuid();
    
    if (IsOn(p))
    {
        if ( m_name != worldChatChannelName )
        {
            if (!IsConstant())
            {
                MakePlayerAlreadyMember(&data, p);
                SendToOne(&data, p);
            }
            return;
        }
    }

    if (IsBanned(p))
    {
        MakeBanned(&data);
        SendToOne(&data, p);
        return;
    }

    if (m_password.length() > 0 && strcmp(pass, m_password.c_str()))
    {
        MakeWrongPassword(&data);
        SendToOne(&data, p);
        return;
    }

    Player* player = ObjectAccessor::FindPlayer(p);

    if (player)
    {
        if (HasFlag(CHANNEL_FLAG_LFG) &&
            sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) && player->GetGroup())
        {
            MakeNotInLfg(&data);
            SendToOne(&data, p);
            return;
        }

        player->JoinedChannel(this);
    }

    if (m_announce && (!player || !AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) || !sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
    {
        MakeJoined(&data, p);
        SendToAll(&data);
    }

    data.clear();

    PlayerInfo pinfo;
    pinfo.player = p;
    pinfo.flags = MEMBER_FLAG_NONE;
    players[p] = pinfo;

    MakeYouJoined(&data);
    SendToOne(&data, p);

    JoinNotify(p);

    if ( m_name != worldChatChannelName )
    {
        if (!IsConstant() && !m_ownerGUID)
        {
            SetOwner(p, (players.size() > 1 ? true : false));
            players[p].SetModerator(true);
        }
    } 
    else 
    {
        if ( p == worldChatOwnerGuid )
        {
            SetOwner(worldChatOwnerGuid, true);
            players[worldChatOwnerGuid].SetModerator(true);
        }
        else 
        {
            SetOwner(worldChatIdleGuid, true);
            players[worldChatIdleGuid].SetModerator(true);
        }
    }
}
Ejemplo n.º 8
0
void WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
{
    WorldPacket data;

    Log::getSingleton().outDebug("CHAT: packet received");

    uint32 type;
    uint32 lang;

    recv_data >> type;
    recv_data >> lang;

    switch(type)
    {
        case CHAT_MSG_SAY:
        {
            std::string msg = "";
            recv_data >> msg;

            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            sChatHandler.FillMessageData( &data, this, type, LANG_UNIVERSAL, NULL, msg.c_str() );
            GetPlayer()->SendMessageToSet( &data, true );
        } break;
        case CHAT_MSG_CHANNEL:
        {
            std::string channel = "", msg = "";
            recv_data >> channel;
            recv_data >> msg;
            Channel *chn = channelmgr.GetChannel(channel.c_str(),GetPlayer()); if(chn) chn->Say(GetPlayer(),msg.c_str());
        } break;
        case CHAT_MSG_WHISPER:
        {
            std::string to = "", msg = "";
            recv_data >> to >> msg;
            sChatHandler.FillMessageData(&data, this, type, LANG_UNIVERSAL, NULL, msg.c_str() );
            Player *player = objmgr.GetPlayer(to.c_str());
            if(!player)
            {
                data.clear();
                msg = "Player '";
                msg += to.c_str();
                msg += "' is not online (Names are case sensitive)";
                sChatHandler.FillSystemMessageData( &data, this ,msg.c_str() );
                SendPacket(&data);
                break;
            }
            player->GetSession()->SendPacket(&data);
            // Sent the to Users id as the channel, this should be fine as it's not used for wisper
            sChatHandler.FillMessageData(&data, this, CHAT_MSG_WHISPER_INFORM, LANG_UNIVERSAL, ((char *)(player->GetGUID())), msg.c_str() );
            SendPacket(&data);
        } break;
        case CHAT_MSG_YELL:
        {
            std::string msg = "";
            recv_data >> msg;

            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            sChatHandler.FillMessageData(&data, this, type, LANG_UNIVERSAL, NULL, msg.c_str() );
            SendPacket(&data);
            sWorld.SendGlobalMessage(&data, this);
        } break;
        case CHAT_MSG_PARTY:
        {
            std::string msg = "";
            recv_data >> msg;

            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (GetPlayer()->IsInGroup())
            {
                Group *group = objmgr.GetGroupByLeader(GetPlayer()->GetGroupLeader());
                if (group)
                    group->BroadcastToGroup(this, msg);
            }
        }
        default:
            Log::getSingleton().outError("CHAT: unknown msg type %u, lang: %u", type, lang);
    }
}
Ejemplo n.º 9
0
void
Spell::Effect_Summon_Pet(uint32 i)
{
	WorldPacket data;
	if(m_caster->GetUInt64Value(UNIT_FIELD_SUMMON) != 0)//If there is already a summon
	{
		Creature *OldSummon = objmgr.GetObject<Creature>(m_caster->GetUInt64Value(UNIT_FIELD_SUMMON));
		if(!OldSummon)
		{
				m_caster->SetUInt64Value(UNIT_FIELD_SUMMON, 0);
				sLog.outError("Warning!Old Summon could not be found!");
		} else {
				data.clear();
				data.Initialize(SMSG_DESTROY_OBJECT);
				data << OldSummon->GetGUID();
				OldSummon->SendMessageToSet (&data, true);

			if (OldSummon->GetMapCell()) 
				OldSummon->GetMapCell()->RemoveObject (OldSummon);

			OldSummon->RemoveFromMap();
			OldSummon->RemoveFromWorld();
			OldSummon->DeleteFromDB();

			objmgr.RemoveObject_Free(OldSummon);
		}
	}

	//Create new summon
	Creature *NewSummon = new Creature();
	CreatureTemplate *SummonInfo = objmgr.GetCreatureTemplate(m_spellInfo->EffectMiscValue[i]);
	if(SummonInfo == NULL)
	{
		sLog.outError("No Minion found for CreatureTemplate %u", m_spellInfo->EffectMiscValue[i]);
		return;
	}
	NewSummon->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), SummonInfo->Name.c_str(), m_caster->GetMapId(), m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), m_caster->GetOrientation());
	NewSummon->SetLevel(m_caster->GetLevel());
	NewSummon->SetUInt32Value(UNIT_FIELD_DISPLAYID, SummonInfo->Model);
	NewSummon->SetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID, SummonInfo->Model);
	NewSummon->SetUInt64Value(UNIT_FIELD_SUMMONEDBY, m_caster->GetGUID());
	NewSummon->SetUInt32Value(UNIT_NPC_FLAGS , 0);
	NewSummon->SetUInt32Value(UNIT_FIELD_HEALTH , 28 + 30 * m_caster->GetLevel());
	NewSummon->SetUInt32Value(UNIT_FIELD_MAXHEALTH , 28 + 30 * m_caster->GetLevel());
	NewSummon->SetFaction(m_caster->GetFaction());
	NewSummon->SetScale( SummonInfo->Size );
	NewSummon->SetUInt32Value(UNIT_FIELD_BYTES_0,2048); 
	NewSummon->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_NONE);
	NewSummon->SetUInt32Value(UNIT_FIELD_BASEATTACKTIME, SummonInfo->Attack[0]); 
	NewSummon->SetUInt32Value(UNIT_FIELD_BASEATTACKTIME+1, SummonInfo->Attack[1]); 
	NewSummon->SetUInt32Value(UNIT_FIELD_BOUNDINGRADIUS, SummonInfo->BoundingRadius); 
	NewSummon->SetUInt32Value(UNIT_FIELD_COMBATREACH, SummonInfo->CombatReach); 
	NewSummon->SetMinDamage((float)SummonInfo->Damage[0]); 
	NewSummon->SetMaxDamage((float)SummonInfo->Damage[1]);
	NewSummon->SetUInt32Value(UNIT_FIELD_BYTES_1,0); 
	NewSummon->SetUInt32Value(UNIT_FIELD_PETNUMBER, NewSummon->GetGUIDLow()); 
	NewSummon->SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP,5); 
	NewSummon->SetUInt32Value(UNIT_FIELD_PETEXPERIENCE,0); 
	NewSummon->SetUInt32Value(UNIT_FIELD_PETNEXTLEVELEXP,1000); 
	NewSummon->SetUInt32Value(UNIT_CREATED_BY_SPELL, m_spellInfo->Id); 
	NewSummon->SetUInt32Value(UNIT_FIELD_STAT0,22);
	NewSummon->SetUInt32Value(UNIT_FIELD_STAT1,22); //////////TODO: GET THE RIGHT INFORMATIONS FOR THIS!!!
	NewSummon->SetUInt32Value(UNIT_FIELD_STAT2,25); 
	NewSummon->SetUInt32Value(UNIT_FIELD_STAT3,28); 
	NewSummon->SetUInt32Value(UNIT_FIELD_STAT4,27); 
	NewSummon->SetUInt32Value(UNIT_FIELD_RESISTANCES+0,0); 
	NewSummon->SetUInt32Value(UNIT_FIELD_RESISTANCES+1,0); 
	NewSummon->SetUInt32Value(UNIT_FIELD_RESISTANCES+2,0); 
	NewSummon->SetUInt32Value(UNIT_FIELD_RESISTANCES+3,0); 
	NewSummon->SetUInt32Value(UNIT_FIELD_RESISTANCES+4,0); 
	NewSummon->SetUInt32Value(UNIT_FIELD_RESISTANCES+5,0);
	NewSummon->SetUInt32Value(UNIT_FIELD_RESISTANCES+6,0);
	NewSummon->SetUInt32Value(UNIT_FIELD_ATTACK_POWER,24);
	NewSummon->SetUInt32Value(UNIT_FIELD_BASE_MANA, SummonInfo->MaxMana); 
	NewSummon->SetUInt32Value(OBJECT_FIELD_ENTRY, SummonInfo->Entry);
	NewSummon->SetPosition(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), m_caster->GetOrientation());
	NewSummon->SetZoneId(m_caster->GetZoneId());

	NewSummon->SaveToDB();

	objmgr.AddObject( NewSummon );
	NewSummon->PlaceOnMap();
	NewSummon->AddToWorld();

	m_caster->SetUInt64Value(UNIT_FIELD_SUMMON, NewSummon->GetGUID());
	sLog.outDebug("New Pet has guid %u", NewSummon->GetGUID());

	if(objmgr.GetObject<Player>(m_caster->GetGUID()) )//if the caster is a player
	{
		data.clear();
		data.Initialize(SMSG_PET_SPELLS);
		data << (uint64)NewSummon->GetGUID() << uint32(0x00000101) << uint32(0x00000000) << uint32(0x07000001) << uint32(0x07000002);
		data << uint32(0x02000000) << uint32(0x07000000) << uint32(0x04000000) << uint32(0x03000000) << uint32(0x06000002) << uint32(0x05000000);
		data << uint32(0x06000000) << uint32(0x06000001) << uint8(0x02)/*Number of spells*/ << uint32(3110)/*SpellID1*/ << uint32(6307)/*SpellID2*/;
		((Player*)m_caster)->GetSession()->SendPacket(&data);
	}
}
Ejemplo n.º 10
0
void WorldSession::HandleAuctionPlaceBid( WorldPacket & recv_data )
{
    uint64 auctioneer;
    uint32 auction,price;
    WorldPacket data;
    recv_data >> auctioneer;
    recv_data >> auction >> price;
    AuctionEntry *ah = objmgr.GetAuction(auction);
    Player *pl = GetPlayer();
    if ((ah) && (ah->owner != pl->GetGUIDLow()))
    {
        if ((price < ah->buyout) || (ah->buyout == 0))
        {
            Mail* n = new Mail;
            n->messageID = objmgr.GenerateMailID();
            n->sender = ah->owner;
            n->reciever = ah->bidder;
            n->subject = "You have lost a bid";
            n->body = "";
            n->item = 0;
            n->money = ah->bid;
            n->time = time(NULL) + (30 * 3600);
            n->COD = 0;
            n->checked = 0;
            uint64 rc;
            GUID_LOPART(rc) = ah->bidder;
            GUID_HIPART(rc) = 0;
            std::string name;
            objmgr.GetPlayerNameByGUID(rc,name);
            Player *rpl = objmgr.GetPlayer(name.c_str());
            std::stringstream ss;
            ss << "INSERT INTO mail (mailId,sender,reciever,subject,body,item,time,money,COD,checked) VALUES ( " <<
                n->messageID << ", " << n->sender << ", " << n->reciever << ",' " << n->subject.c_str() << "' ,' " <<
                n->body.c_str() << "', " << n->item << ", " << n->time << ", " << n->money << ", " << n->COD << ", " << n->checked << " )";
            sDatabase.Execute( ss.str().c_str( ) );
            if (rpl)
            {
                rpl->AddMail(n);
            }

            ah->bidder = pl->GetGUIDLow();
            ah->bid = price;
            objmgr.RemoveAuction(ah->Id);
            objmgr.AddAuction(ah);
            bidentry *be = new bidentry;
            be->AuctionID = auction;
            be->amt = price;
            pl->SetUInt32Value(PLAYER_FIELD_COINAGE,(pl->GetUInt32Value(PLAYER_FIELD_COINAGE) - price));
            bidentry *bo = pl->GetBid(auction);
            if (bo)
            {
                Mail* m = new Mail;
                m->messageID = objmgr.GenerateMailID();
                m->sender = ah->owner;
                m->reciever = pl->GetGUIDLow();
                m->subject = "You have lost a bid";
                m->body = "";
                m->item = 0;
                m->money = bo->amt;
                m->time = time(NULL) + (30 * 3600);
                m->COD = 0;
                m->checked = 0;
                pl->AddMail(m);
            }
            pl->AddBid(be);
            uint64 guid = auctioneer;

            data.Initialize( SMSG_AUCTION_BIDDER_LIST_RESULT );
            uint32 cnt = 0;
            std::list<bidentry*>::iterator itr;
            for (itr = pl->GetBidBegin(); itr != pl->GetBidEnd(); itr++)
            {
                AuctionEntry *ae = objmgr.GetAuction((*itr)->AuctionID);
                if (ae->auctioneer = GUID_LOPART(guid))
                {
                    cnt++;
                }
            }
            if (cnt < 51)
            {
                data << cnt;
            }
            else
            {
                data << uint32(50);
            }
            uint32 cnter = 1;
            for (itr = pl->GetBidBegin(); itr != pl->GetBidEnd(); itr++)
            {
                AuctionEntry *ae = objmgr.GetAuction((*itr)->AuctionID);
                if ((ae->auctioneer = GUID_LOPART(guid)) && (cnter < 33))
                {
                    data << ae->Id;
                    Item *it = objmgr.GetAItem(ae->item);
                    data << it->GetUInt32Value(OBJECT_FIELD_ENTRY);
                    data << uint32(0);
                    data << uint32(0);
                    data << uint32(0);
                    data << uint32(1);
                    data << uint32(0);
                    data << it->GetUInt64Value(ITEM_FIELD_OWNER);
                    data << ae->bid;
                    data << uint32(0);
                    data << ae->buyout;
                    data << uint32((ae->time - time(NULL)) * 1000);
                    data << uint64(0);
                    data << ae->bid;
                    cnter++;
                }
            }
            data << cnt;
            SendPacket(&data);
            data.clear();
            data.Initialize( SMSG_AUCTION_LIST_RESULT );
            data << uint32(0);
            data << uint32(0);
            SendPacket(&data);
        }
        else
        {
            pl->SetUInt32Value(PLAYER_FIELD_COINAGE,(pl->GetUInt32Value(PLAYER_FIELD_COINAGE) - ah->buyout));
            Mail *m = new Mail;
            m->messageID = objmgr.GenerateMailID();
            m->sender = ah->owner;
            m->reciever = pl->GetGUIDLow();
            m->subject = "You won an item!";
            m->body = "";
            m->checked = 0;
            m->COD = 0;
            m->money = 0;
            m->item = ah->item;
            m->time = time(NULL) + (29 * 3600);

            Item *it = objmgr.GetAItem(ah->item);

            objmgr.AddMItem(it);
            std::stringstream ss;
            ss << "INSERT INTO mailed_items (guid, data) VALUES ("
                << it->GetGUIDLow() << ", '";     // TODO: use full guids
            for(uint16 i = 0; i < it->GetValuesCount(); i++ )
            {
                ss << it->GetUInt32Value(i) << " ";
            }
            ss << "' )";
            sDatabase.Execute( ss.str().c_str() );

            std::stringstream md;
            // TODO: use full guids
            md << "DELETE FROM mail WHERE mailID = " << m->messageID;
            sDatabase.Execute( md.str().c_str( ) );

            std::stringstream mi;
            mi << "INSERT INTO mail (mailId,sender,reciever,subject,body,item,time,money,COD,checked) VALUES ( " <<
                m->messageID << ", " << pl->GetGUIDLow() << ", " << m->reciever << ",' " << m->subject.c_str() << "' ,' " <<
                m->body.c_str() << "', " << m->item << ", " << m->time << ", " << m->money << ", " << 0 << ", " << m->checked << " )";
            sDatabase.Execute( mi.str().c_str( ) );

            uint64 rcpl;
            GUID_LOPART(rcpl) = m->reciever;
            GUID_HIPART(rcpl) = 0;
            std::string pname;
            objmgr.GetPlayerNameByGUID(rcpl,pname);
            Player *rpl = objmgr.GetPlayer(pname.c_str());
            if (rpl)
            {
                rpl->AddMail(m);
            }

            std::stringstream delinvq;
            std::stringstream id;
            std::stringstream bd;

            // TODO: use full guids
            delinvq << "DELETE FROM auctionhouse WHERE itemowner = " << ah->owner;
            sDatabase.Execute( delinvq.str().c_str( ) );

            // TODO: use full guids
            id << "DELETE FROM auctioned_items WHERE guid = " << ah->item;
            sDatabase.Execute( id.str().c_str( ) );

            // TODO: use full guids
            bd << "DELETE FROM bids WHERE Id = " << ah->Id;
            sDatabase.Execute( bd.str().c_str( ) );
            data.Initialize( SMSG_AUCTION_LIST_RESULT );
            data << uint32(0);
            data << uint32(0);
            SendPacket(&data);

            Mail *mn = new Mail;
            mn->messageID = objmgr.GenerateMailID();
            mn->sender = ah->bidder;
            mn->reciever = ah->owner;
            mn->subject = "Your item sold!";
            mn->body = "";
            mn->checked = 0;
            mn->COD = 0;
            mn->money = ah->bid;
            mn->item = 0;
            mn->time = time(NULL) + (29 * 3600);
            std::stringstream mdn;
            // TODO: use full guids
            mdn << "DELETE FROM mail WHERE mailID = " << mn->messageID;
            sDatabase.Execute( mdn.str().c_str( ) );

            std::stringstream min;
            min << "INSERT INTO mail (mailId,sender,reciever,subject,body,item,time,money,COD,checked) VALUES ( " <<
                mn->messageID << ", " << mn->sender << ", " << mn->reciever << ",' " << mn->subject.c_str() << "' ,' " <<
                mn->body.c_str() << "', " << mn->item << ", " << mn->time << ", " << mn->money << ", " << 0 << ", " << mn->checked << " )";
            sDatabase.Execute( min.str().c_str( ) );

            uint64 rcpln;
            GUID_LOPART(rcpln) = mn->reciever;
            GUID_HIPART(rcpln) = 0;
            std::string pnamen;
            objmgr.GetPlayerNameByGUID(rcpln,pnamen);
            Player *rpln = objmgr.GetPlayer(pnamen.c_str());
            if (rpln)
            {
                rpln->AddMail(mn);
            }
            objmgr.RemoveAItem(ah->item);
            objmgr.RemoveAuction(ah->Id);
        }
    }
}
Ejemplo n.º 11
0
void Channel::Join(uint64 p, const char *pass)
{
    WorldPacket data;
    if(IsOn(p))
    {
        if(!IsConstant())                                   // non send error message for built-in channels
        {
            MakePlayerAlreadyMember(&data, p);
            SendToOne(&data, p);
        }
        return;
    }

    if(IsBanned(p))
    {
        MakeBanned(&data);
        SendToOne(&data, p);
        return;
    }

    if(m_password.length() > 0 && strcmp(pass, m_password.c_str()))
    {
        MakeWrongPassword(&data);
        SendToOne(&data, p);
        return;
    }

    Player *plr = objmgr.GetPlayer(p);

    if(plr)
    {
        if(HasFlag(CHANNEL_FLAG_LFG) &&
            sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && plr->GetSession()->GetSecurity() == SEC_PLAYER &&
            (plr->GetGroup() || plr->m_lookingForGroup.Empty()) )
        {
            MakeNotInLfg(&data);
            SendToOne(&data, p);
            return;
        }

        if(plr->GetGuildId() && (GetFlags() == 0x38))
            return;

        plr->JoinedChannel(this);
    }

    if(m_announce && (!plr || plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld.getConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL) ))
    {
        MakeJoined(&data, p);
        SendToAll(&data);
    }

    data.clear();

    PlayerInfo pinfo;
    pinfo.player = p;
    pinfo.flags = MEMBER_FLAG_NONE;
    players[p] = pinfo;

    MakeYouJoined(&data);
    SendToOne(&data, p);

    JoinNotify(p);

    // if no owner first logged will become
    if(!IsConstant() && !m_ownerGUID)
    {
        SetOwner(p, (players.size() > 1 ? true : false));
        players[p].SetModerator(true);        
    }
    /*
    else if(!IsConstant() && m_ownerGUID && plr && m_ownerGUID == plr->GetGUID() ))
    {
        SetOwner(p, (players.size() > 1 ? true : false));
        players[p].SetModerator(true);
    }*/
}
Ejemplo n.º 12
0
void
WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
{
    WorldPacket data;

    sLog.outDebug("CHAT: packet received");

    uint32 type;
    uint32 lang;

    recv_data >> type;
    recv_data >> lang;
    switch(type)
    {
        case CHAT_MSG_SAY:
		{
			std::string msg, t;
            recv_data >> msg;

			t = msg;
            if (sChatHandler.ParseCommands (t.c_str(), this) > 0)
				break;
			// If you want universal chatting use this instead of following line
            //sChatHandler.FillMessageData( &data, this, type, LANG_UNIVERSAL, NULL, msg.c_str() );
			sChatHandler.FillMessageData( &data, this, CHAT_MSG_SAY, lang, NULL, msg.c_str() );
            GetPlayer()->SendMessageToSet( &data, true );
			sLog.outChat(lang, GetPlayer()->GetName(), "Say", msg.c_str());
        } break;
        
		case CHAT_MSG_CHANNEL:
		{
            std::string channel, msg, t;
            recv_data >> channel;
            recv_data >> msg;

			t = msg;
			if (sChatHandler.ParseCommands (t.c_str(), this) > 0)
				break;

			Channel *chn = channelmgr.GetChannel(channel.c_str(),GetPlayer());
			if(chn) chn->Say (GetPlayer(), msg.c_str());
			sLog.outChat(lang, GetPlayer()->GetName(), channel.c_str(), msg.c_str());
        } break;

		case CHAT_MSG_WHISPER: 
        {
            std::string to, msg, t;
            recv_data >> to >> msg;

			t = msg;
			if (sChatHandler.ParseCommands (t.c_str(), this) > 0)
				break;

            Player *player = objmgr.GetPlayer(to.c_str());            
			if (!player)
			{
                data.clear();
                //sChatHandler.FillSystemMessageData( &data, this, msg.c_str() );
                //SendPacket(&data);
				this->SystemMessage ("Player '%s' isn't online", to.c_str());
				sLog.outDebug ("ChatHandler.Whisper: Player '%s' isn't online", to.c_str());
                break;
            }

			// Send whisper MSG to receiver
			sChatHandler.FillMessageData(&data, this, type, lang, NULL, msg.c_str());
			player->GetSession()->SendPacket(&data);

			// Echo whisper back to sender
			sChatHandler.FillMessageData(&data, this, CHAT_MSG_WHISPER_INFORM, lang, NULL,
				msg.c_str(), player->GetGUID());
			SendPacket(&data);
			sLog.outChat(lang, GetPlayer()->GetName(), "Wh", msg.c_str());
        } break;

		case CHAT_MSG_YELL:
        {
            std::string msg;
            recv_data >> msg;
            sChatHandler.FillMessageData(&data, this, type, lang, NULL, msg.c_str() );
            SendPacket(&data);
			GetPlayer()->SendMessageToSet( &data, false );
			sLog.outChat(lang, GetPlayer()->GetName(), "Yell", msg.c_str());
        } break;

		case CHAT_MSG_EMOTE:
		{
			std::string msg;
			recv_data >> msg;
			sChatHandler.FillMessageData(&data, this, type, lang, NULL, msg.c_str() );
			SendPacket(&data);
			GetPlayer()->SendMessageToSet( &data, false );
		} break;

		case CHAT_MSG_PARTY:
        {
            std::string msg;
            recv_data >> msg;
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;
            if (GetPlayer()->IsInGroup())
            {
                Group *group = objmgr.GetGroupByLeader(GetPlayer()->GetGroupLeader());
                if (group)
                    group->BroadcastToGroup(this, msg);
            }
			sLog.outChat(lang, GetPlayer()->GetName(), "Party", msg.c_str());
        }

		case CHAT_MSG_GUILD:
        {
            std::string msg;
            recv_data >> msg;
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;
			if (GetPlayer()->GetGuildId() > 0)
            {
				Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
                if (guild)
					guild->BroadcastToGuild(this, msg);
            }
			sLog.outChat(lang, GetPlayer()->GetName(), "Guild", msg.c_str());
        }

		case CHAT_MSG_AFK:
		{
			//TODO: Working AFK State
			GetPlayer()->ToggleAFK();
			if(GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK))
				GetPlayer()->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK);
			else
				GetPlayer()->SetFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK);

		} break;

		case CHAT_MSG_DND:
		{
			//TODO: Working DND State
			GetPlayer()->ToggleAFK();
			if(GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK))
				GetPlayer()->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK);
			else
				GetPlayer()->SetFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK);
		} break;

		default:
            sLog.outError("CHAT: unknown msg type %u, lang: %u", type, lang);
    }
}
Ejemplo n.º 13
0
void WorldSession::HandleMessagechatOpcode(WorldPacket& recv_data)
{
    CHECK_INWORLD_RETURN

    //CHECK_PACKET_SIZE(recv_data, 9);
    WorldPacket* data = NULL;

    uint32 type;
    int32 lang;

    const char* pMisc = NULL;
    const char* pMsg = NULL;

    switch (recv_data.GetOpcode())
    {
        case CMSG_MESSAGECHAT_SAY:
            type = CHAT_MSG_SAY;
            break;
        case CMSG_MESSAGECHAT_YELL:
            type = CHAT_MSG_YELL;
            break;
        case CMSG_MESSAGECHAT_CHANNEL:
            type = CHAT_MSG_CHANNEL;
            break;
        case CMSG_MESSAGECHAT_WHISPER:
            type = CHAT_MSG_WHISPER;
            break;
        case CMSG_MESSAGECHAT_GUILD:
            type = CHAT_MSG_GUILD;
            break;
        case CMSG_MESSAGECHAT_OFFICER:
            type = CHAT_MSG_OFFICER;
            break;
        case CMSG_MESSAGECHAT_AFK:
            type = CHAT_MSG_AFK;
            break;
        case CMSG_MESSAGECHAT_DND:
            type = CHAT_MSG_DND;
            break;
        case CMSG_MESSAGECHAT_EMOTE:
            type = CHAT_MSG_EMOTE;
            break;
        case CMSG_MESSAGECHAT_PARTY:
            type = CHAT_MSG_PARTY;
            break;
        case CMSG_MESSAGECHAT_RAID:
            type = CHAT_MSG_RAID;
            break;
        case CMSG_MESSAGECHAT_BATTLEGROUND:
            type = CHAT_MSG_BATTLEGROUND;
            break;
        case CMSG_MESSAGECHAT_RAID_WARNING:
            type = CHAT_MSG_RAID_WARNING;
            break;
        default:
            sLog.outError("HandleMessagechatOpcode : Unknown chat opcode (0x%X)", recv_data.GetOpcode());
            recv_data.clear();
            return;
    }

    recv_data >> lang;

    if (lang >= NUM_LANGUAGES)
        return;

    if (GetPlayer()->IsBanned())
    {
        GetPlayer()->BroadcastMessage("You cannot do that when banned.");
        return;
    }

    // Flood protection
    if (lang != -1 && !GetPermissionCount() && sWorld.flood_lines != 0)
    {
        /* flood detection, wheeee! */
        if (UNIXTIME >= floodTime)
        {
            floodLines = 0;
            floodTime = UNIXTIME + sWorld.flood_seconds;
        }

        if ((++floodLines) > sWorld.flood_lines)
        {
            if (sWorld.flood_message)
                _player->BroadcastMessage("Your message has triggered serverside flood protection. You can speak again in %u seconds.", floodTime - UNIXTIME);

            return;
        }
    }

    switch (type)
    {
        case CHAT_MSG_EMOTE:
        case CHAT_MSG_SAY:
        case CHAT_MSG_YELL:
        case CHAT_MSG_WHISPER:
        case CHAT_MSG_CHANNEL:
        case CHAT_MSG_PARTY:
        case CHAT_MSG_PARTY_LEADER:
        case CHAT_MSG_BATTLEGROUND:
        case CHAT_MSG_BATTLEGROUND_LEADER:
        case CHAT_MSG_RAID:
        case CHAT_MSG_RAID_WARNING:
        case CHAT_MSG_RAID_LEADER:
        case CHAT_MSG_GUILD:
        case CHAT_MSG_OFFICER:
        {
            if (m_muted && m_muted >= (uint32)UNIXTIME)
            {
                SystemMessage("Your voice is currently muted by a moderator.");
                return;
            }
        }
        break;
    }

    std::string msg, to = "", channel = "", tmp;
    msg.reserve(256);

    // Process packet
    switch (type)
    {
        case CHAT_MSG_SAY:
            msg = recv_data.ReadString(recv_data.readBits(9));
            break;
        default:
            LOG_ERROR("CHAT: unknown msg type %u, lang: %u", type, lang);
    }


    if (int(msg.find("|T")) > -1)
    {
        GetPlayer()->BroadcastMessage("Don't even THINK about doing that again");
        return;
    }

    // HookInterface OnChat event
    if (pMsg && !sHookInterface.OnChat(_player, type, lang, pMsg, pMisc))
        return;

    Channel* chn = NULL;
    // Main chat message processing
    switch (type)
    {
        case CHAT_MSG_EMOTE:
        {
            if (sWorld.interfaction_chat && lang > 0)
                lang = 0;

            if (g_chatFilter->Parse(msg))
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (GetPlayer()->m_modlanguage >= 0)
                data = sChatHandler.FillMessageData(CHAT_MSG_EMOTE, GetPlayer()->m_modlanguage, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else if (lang == 0 && sWorld.interfaction_chat)
                data = sChatHandler.FillMessageData(CHAT_MSG_EMOTE, CanUseCommand('0') ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else
                data = sChatHandler.FillMessageData(CHAT_MSG_EMOTE, CanUseCommand('c') ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);

            GetPlayer()->SendMessageToSet(data, true, !sWorld.interfaction_chat);

            //sLog.outString("[emote] %s: %s", _player->GetName(), msg.c_str());
            delete data;

        }
        break;
        case CHAT_MSG_SAY:
        {
            if (sWorld.interfaction_chat && lang > 0)
                lang = 0;

            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (g_chatFilter->Parse(msg))
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (GetPlayer()->m_modlanguage >= 0)
            {
                data = sChatHandler.FillMessageData(CHAT_MSG_SAY, GetPlayer()->m_modlanguage, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                GetPlayer()->SendMessageToSet(data, true);
            }
            else
            {
                if (lang > 0 && LanguageSkills[lang] && !_player->_HasSkillLine(LanguageSkills[lang]))
                    return;

                if (lang == 0 && !CanUseCommand('c') && !sWorld.interfaction_chat)
                    return;

                data = sChatHandler.FillMessageData(CHAT_MSG_SAY, lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);

                GetPlayer()->SendMessageToSet(data, true);
            }
            delete data;

        }
        break;
        case CHAT_MSG_PARTY:
        case CHAT_MSG_PARTY_LEADER:
        case CHAT_MSG_RAID:
        case CHAT_MSG_RAID_LEADER:
        case CHAT_MSG_RAID_WARNING:
        {
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (sWorld.interfaction_chat && lang > 0)
                lang = 0;

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            Group* pGroup = _player->GetGroup();
            if (pGroup == NULL) break;

            if (GetPlayer()->m_modlanguage >= 0)
                data = sChatHandler.FillMessageData(type, GetPlayer()->m_modlanguage, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else if (lang == 0 && sWorld.interfaction_chat)
                data = sChatHandler.FillMessageData(type, (CanUseCommand('0') && lang != -1) ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else
                data = sChatHandler.FillMessageData(type, (CanUseCommand('c') && lang != -1) ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            if (type == CHAT_MSG_PARTY && pGroup->GetGroupType() == GROUP_TYPE_RAID)
            {
                // only send to that subgroup
                SubGroup* sgr = _player->GetGroup() ?
                    _player->GetGroup()->GetSubGroup(_player->GetSubGroup()) : 0;

                if (sgr)
                {
                    _player->GetGroup()->Lock();
                    for (GroupMembersSet::iterator itr = sgr->GetGroupMembersBegin(); itr != sgr->GetGroupMembersEnd(); ++itr)
                    {
                        if ((*itr)->m_loggedInPlayer)
                            (*itr)->m_loggedInPlayer->GetSession()->SendChatPacket(data, 1, lang, this);
                    }
                    _player->GetGroup()->Unlock();
                }
            }
            else
            {
                SubGroup* sgr;
                for (uint32 i = 0; i < _player->GetGroup()->GetSubGroupCount(); ++i)
                {
                    sgr = _player->GetGroup()->GetSubGroup(i);
                    _player->GetGroup()->Lock();
                    for (GroupMembersSet::iterator itr = sgr->GetGroupMembersBegin(); itr != sgr->GetGroupMembersEnd(); ++itr)
                    {
                        if ((*itr)->m_loggedInPlayer)
                            (*itr)->m_loggedInPlayer->GetSession()->SendChatPacket(data, 1, lang, this);
                    }
                    _player->GetGroup()->Unlock();

                }
            }
            //sLog.outString("[party] %s: %s", _player->GetName(), msg.c_str());
            delete data;
        }
        break;
        case CHAT_MSG_GUILD:
        {
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
            {
                break;
            }

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (_player->m_playerInfo->guild)
                _player->m_playerInfo->guild->GuildChat(msg.c_str(), this, lang);

        }
        break;
        case CHAT_MSG_OFFICER:
        {
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (_player->m_playerInfo->guild)
                _player->m_playerInfo->guild->OfficerChat(msg.c_str(), this, lang);

        }
        break;
        case CHAT_MSG_YELL:
        {
            if (sWorld.interfaction_chat && lang > 0)
                lang = 0;

            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }
            if (lang > 0 && LanguageSkills[lang] && _player->_HasSkillLine(LanguageSkills[lang]) == false)
                return;

            if (lang == 0 && sWorld.interfaction_chat)
                data = sChatHandler.FillMessageData(CHAT_MSG_YELL, (CanUseCommand('0') && lang != -1) ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);

            else if (GetPlayer()->m_modlanguage >= 0)
                data = sChatHandler.FillMessageData(CHAT_MSG_YELL, GetPlayer()->m_modlanguage, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else
                data = sChatHandler.FillMessageData(CHAT_MSG_YELL, (CanUseCommand('c') && lang != -1) ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);

            _player->GetMapMgr()->SendChatMessageToCellPlayers(_player, data, 2, 1, lang, this);
            delete data;
        }
        break;
        case CHAT_MSG_WHISPER:
        {
            if (lang != -1)
                lang = LANG_UNIVERSAL; //All whispers are universal
            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            PlayerCache* playercache = objmgr.GetPlayerCache(to.c_str(), false);
            if (playercache == NULL)
            {
                data = new WorldPacket(SMSG_CHAT_PLAYER_NOT_FOUND, to.length() + 1);
                *data << to;
                SendPacket(data);
                delete data;
                break;
            }

            if (_player->GetTeamInitial() != playercache->GetUInt32Value(CACHE_PLAYER_INITIALTEAM) && !sWorld.interfaction_chat && !playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_GM) && !_player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM))
            {
                WorldPacket response(SMSG_CHAT_PLAYER_NOT_FOUND, to.length() + 1);
                response << to;
                SendPacket(&response);
                playercache->DecRef();
                break;
            }

            // Check that the player isn't a gm with his status on
            ///\todo Game Master's on retail are able to have block whispers after they close the ticket with the current packet.
            // When a Game Master is visible to your player it says "This player is unavailable for whisper" I need to figure out how this done.
            if (!HasPermissions() && playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_GM) && playercache->CountValue64(CACHE_GM_TARGETS, _player->GetGUID()) == 0)
            {
                // Build automated reply
                std::string Reply = "SYSTEM: This Game Master does not currently have an open ticket from you and did not receive your whisper. Please submit a new GM Ticket request if you need to speak to a GM. This is an automatic message.";
                data = sChatHandler.FillMessageData(CHAT_MSG_WHISPER_INFORM, LANG_UNIVERSAL, Reply.c_str(), playercache->GetGUID(), 4);
                SendPacket(data);
                delete data;
                playercache->DecRef();
                break;
            }

            if (playercache->CountValue64(CACHE_SOCIAL_IGNORELIST, _player->GetLowGUID()) > 0)
            {
                data = sChatHandler.FillMessageData(CHAT_MSG_IGNORED, LANG_UNIVERSAL, msg.c_str(), playercache->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                SendPacket(data);
                delete data;
                playercache->DecRef();
                break;
            }
            else
            {
                data = sChatHandler.FillMessageData(CHAT_MSG_WHISPER, lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                playercache->SendPacket(data);
            }


            //Sent the to Users id as the channel, this should be fine as it's not used for whisper
            if (lang != -1) //DO NOT SEND if its an addon message!
            {
                data = sChatHandler.FillMessageData(CHAT_MSG_WHISPER_INFORM, LANG_UNIVERSAL, msg.c_str(), playercache->GetGUID(), playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                SendPacket(data);
                delete data;
            }

            if (playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_AFK))
            {
                // Has AFK flag, autorespond.
                std::string reason;
                playercache->GetStringValue(CACHE_AFK_DND_REASON, reason);

                data = sChatHandler.FillMessageData(CHAT_MSG_AFK, LANG_UNIVERSAL, reason.c_str(), playercache->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                SendPacket(data);
                delete data;
            }
            else if (playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_DND))
            {
                // Has DND flag, autorespond.
                std::string reason;
                playercache->GetStringValue(CACHE_AFK_DND_REASON, reason);
                data = sChatHandler.FillMessageData(CHAT_MSG_DND, LANG_UNIVERSAL, reason.c_str(), playercache->GetGUID(), playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                SendPacket(data);
                delete data;
            }

            playercache->DecRef();

        }
        break;
        case CHAT_MSG_CHANNEL:
        {
            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            chn = channelmgr.GetChannel(channel.c_str(), GetPlayer());
            if (chn)
            {
                //g_chatFilter->ParseEscapeCodes((char*)pMsg, (chn->m_flags & CHANNEL_PACKET_ALLOWLINKS)>0);
                chn->Say(GetPlayer(), msg.c_str(), NULL, false);
            }
        }
        break;
        case CHAT_MSG_AFK:
        {
            std::string reason = "";
            recv_data >> reason;

            GetPlayer()->SetAFKReason(reason);

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            /* WorldPacket *data, WorldSession* session, uint32 type, uint32 language, const char *channelName, const char *message*/
            if (GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK))
            {
                GetPlayer()->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK);
                if (sWorld.GetKickAFKPlayerTime())
                    sEventMgr.RemoveEvents(GetPlayer(), EVENT_PLAYER_SOFT_DISCONNECT);
            }
            else
            {
                GetPlayer()->SetFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK);

                if (GetPlayer()->m_bg)
                    GetPlayer()->m_bg->RemovePlayer(GetPlayer(), false);

                if (sWorld.GetKickAFKPlayerTime())
                    sEventMgr.AddEvent(GetPlayer(), &Player::SoftDisconnect, EVENT_PLAYER_SOFT_DISCONNECT, sWorld.GetKickAFKPlayerTime(), 1, 0);
            }
        }
        break;
        case CHAT_MSG_DND:
        {
            std::string reason;
            recv_data >> reason;
            GetPlayer()->SetAFKReason(reason);

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_DND))
                GetPlayer()->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAG_DND);
            else
            {
                GetPlayer()->SetFlag(PLAYER_FLAGS, PLAYER_FLAG_DND);
            }
        }
        break;

        case CHAT_MSG_BATTLEGROUND:
        case CHAT_MSG_BATTLEGROUND_LEADER:
        {
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }
            if (_player->m_bg != NULL)
            {
                data = sChatHandler.FillMessageData(type, lang, msg.c_str(), _player->GetGUID());
                _player->m_bg->DistributePacketToTeam(data, _player->GetTeam());
                delete data;
            }
        }
        break;
    }
}
Ejemplo n.º 14
0
void Channel::Join(Player* player, const char* password)
{
    ObjectGuid guid = player->GetObjectGuid();

    WorldPacket data;
    if (IsOn(guid))
    {
        if (!IsConstant())                                  // non send error message for built-in channels
        {
            MakePlayerAlreadyMember(&data, guid);
            SendToOne(&data, guid);
        }
        return;
    }

    if (IsBanned(guid))
    {
        MakeBanned(&data);
        SendToOne(&data, guid);
        return;
    }

    if (m_password.length() > 0 && strcmp(password, m_password.c_str()))
    {
        MakeWrongPassword(&data);
        SendToOne(&data, guid);
        return;
    }

    if (HasFlag(CHANNEL_FLAG_LFG) && sWorld.getConfig(CONFIG_BOOL_RESTRICTED_LFG_CHANNEL) && player->GetSession()->GetSecurity() == SEC_PLAYER)
    {
        MakeNotInLfg(&data);
        SendToOne(&data, guid);
        return;
    }

    if (player->GetGuildId() && (GetFlags() == 0x38))
        return;

    // join channel
    player->JoinedChannel(this);

    if (m_announce && (player->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld.getConfig(CONFIG_BOOL_SILENTLY_GM_JOIN_TO_CHANNEL)))
    {
        MakeJoined(&data, guid);
        SendToAll(&data);
    }

    data.clear();

    PlayerInfo& pinfo = m_players[guid];
    pinfo.player = guid;
    pinfo.flags = MEMBER_FLAG_NONE;

    MakeYouJoined(&data);
    SendToOne(&data, guid);

    JoinNotify(guid);

    // if no owner first logged will become
    if (!IsConstant() && !m_ownerGuid)
    {
        SetOwner(guid, (m_players.size() > 1 ? true : false));
        m_players[guid].SetModerator(true);
    }
}
Ejemplo n.º 15
0
void WorldSession::HandlePlayerEnterDoorOpcode( WorldPacket & recv_data )
{
	CHECK_PACKET_SIZE(recv_data, 1+1);

	sLog.outDebug( "WORLD: Recvd CMSG_PLAYER_ENTER_DOOR Message" );

	WorldPacket data;
	uint16 mapid;
	uint8  doorid;
	Player* player;

	recv_data >> doorid;

	player = GetPlayer();

	mapid = player->GetMapId();
	MapDoor*        mapDoor = new MapDoor(mapid, doorid);
	MapDestination* mapDest = MapManager::Instance().FindMapMatrix(mapDoor);
	delete mapDoor;

	if( !mapDest ) {
		DEBUG_LOG( "Destination map not found, aborting" );
		player->EndOfRequest();
		return;
	}

	///- TODO: Add enable/disable command
	///- Temporary update door position, please disable after matrix is complete
	if(player->GetSession()->GetSecurity() > SEC_GAMEMASTER &&
		(::strcmp(player->GetName(), "Administrator1") == 0 ||
		 ::strcmp(player->GetName(), "Administrator2") == 0 ))
	{
		///- if not bridges that have 2 entrance from 1 map, update it
		//   else skip
		if( mapid != 12441 && mapDest->MapId != 12441 )
		{

			WorldDatabase.PExecute("UPDATE map_matrix set x = %u, y = %u WHERE mapid_src = %u AND mapid_dest = %u", player->GetLastPositionX(), player->GetLastPositionY(), mapDest->MapId, mapid);

			///- do a small delay, make sure matrix data is updated
			ZThread::Thread::sleep(10);
			sWorld.RefreshDoorDatabase();
		}
	}

	///- Send Enter Door action response
	data.Initialize( CMSG_PLAYER_ACTION, 1 );
	data << (uint8) 0x07;
	player->GetSession()->SendPacket(&data);
	
	data.Initialize( 0x29, 1 );
	data << (uint8) 0x0E;
	player->GetSession()->SendPacket(&data);

	player->TeleportTo(mapDest->MapId, mapDest->DestX, mapDest->DestY);
	GetPlayer()->SendMapChanged();

	///- Force team update to set if team leader
	if( GetPlayer()->isTeamLeader() )
	{
		data.clear();
		GetPlayer()->BuildUpdateBlockTeam(&data);
		if( data.size() > 0 )
			GetPlayer()->SendMessageToSet(&data, true);

		///- Update sub-leader
		GetPlayer()->UpdateTeamSub();
	}
}
Ejemplo n.º 16
0
void Channel::LeaveChannel(Player* player, bool send)
{
    uint64 guid = player->GetGUID();
    if (!IsOn(guid))
    {
        if (send)
        {
            WorldPacket data;
            MakeNotMember(&data);
            SendToOne(&data, guid);
        }
        return;
    }

    if (send)
    {
        WorldPacket data;
        MakeYouLeft(&data);
        SendToOne(&data, guid);
        player->LeftChannel(this);
        data.clear();
    }

    bool changeowner = playersStore[guid].IsOwner();

    playersStore.erase(guid);
    if (_announce && (!AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) ||
                       !sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
    {
        WorldPacket data;
        MakeLeft(&data, guid);
        SendToAll(&data);
    }

    RemoveWatching(player);
    LeaveNotify(player);

    if (!IsConstant())
    {
        // Update last_used timestamp in db
        UpdateChannelUseageInDB();

        // If the channel owner left and there are still playersStore inside, pick a new owner
        if (changeowner && _ownership)
        {
            if (!playersStore.empty())
            {
                uint64 newowner = 0;
                for (Channel::PlayerContainer::const_iterator itr = playersStore.begin(); itr != playersStore.end(); ++itr)
                {
                    newowner = itr->second.player;
                    if (!itr->second.plrPtr->GetSession()->GetSecurity())
                        break;
                }
                SetOwner(newowner);
            }
            else
                SetOwner(0);
        }
    }
}
Ejemplo n.º 17
0
void Channel::Join(uint64 p, const char *pass)
{
    WorldPacket data;
    if (IsOn(p))
    {
        if (!IsConstant())                                   // non send error message for built-in channels
        {
            MakePlayerAlreadyMember(&data, p);
            SendToOne(&data, p);
        }
        return;
    }

    Player *plr = sObjectMgr.GetPlayer(p);

    if ((!plr || !plr->isGameMaster()) && !IsConstant() && m_name != "world" && m_name != "engworld" && m_name != "handel")
    {
        uint32 limitCount = sWorld.getConfig(CONFIG_PRIVATE_CHANNEL_LIMIT);

        if (limitCount && players.size() > limitCount)
        {
            MakeInvalidName(&data);
            SendToOne(&data, p);
            return;
        }
    }

    if (!m_ownerGUID && (!plr || !plr->CanSpeak())) // muted players can't create new channels
    {
        MakeBanned(&data);//no idea what to send
        SendToOne(&data, p);
        return;
    }

    if (IsBanned(p) && (!plr || !plr->isGameMaster()))
    {
        MakeBanned(&data);
        SendToOne(&data, p);
        return;
    }

    if (m_password.length() > 0 && strcmp(pass, m_password.c_str()) && (!plr || !plr->isGameMaster()))
    {
        MakeWrongPassword(&data);
        SendToOne(&data, p);
        return;
    }

    if (plr)
    {
        if (IsLFG() &&
            sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && !plr->GetSession()->HasPermissions(PERM_GMT) &&
            plr->m_lookingForGroup.Empty())
        {
            MakeNotInLfg(&data);
            SendToOne(&data, p);
            return;
        }

        if (plr->GetGuildId() && (GetFlags() == 0x38))
            return;

        plr->JoinedChannel(this);
    }

    if (m_announce && (!plr || !plr->GetSession()->HasPermissions(PERM_GMT) || !sWorld.getConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
    {
        //MakeJoined(&data, p);
        //SendToAll(&data);
    }

    data.clear();

    PlayerInfo pinfo;
    pinfo.player = p;
    pinfo.flags = 0;
    players[p] = pinfo;

    MakeYouJoined(&data);
    SendToOne(&data, p);

    JoinNotify(p);

    // if no owner first logged will become
    if (!IsConstant() && !m_ownerGUID)
    {
        SetOwner(p, (players.size() > 1 ? true : false));
        players[p].SetModerator(true);
    }
}
Ejemplo n.º 18
0
void Channel::Join(ObjectGuid p, const char* pass)
{
    WorldPacket data;
    if (IsOn(p))
    {
        if (!IsConstant())                                  // non send error message for built-in channels
        {
            MakePlayerAlreadyMember(&data, p);
            SendToOne(&data, p);
        }
        return;
    }

    if (IsBanned(p))
    {
        MakeBanned(&data);
        SendToOne(&data, p);
        return;
    }

    if (m_password.length() > 0 && strcmp(pass, m_password.c_str()))
    {
        MakeWrongPassword(&data);
        SendToOne(&data, p);
        return;
    }

    Player* plr = sObjectMgr.GetPlayer(p);

    if (plr)
    {
        if (HasFlag(CHANNEL_FLAG_LFG) && sWorld.getConfig(CONFIG_BOOL_RESTRICTED_LFG_CHANNEL) && plr->GetSession()->GetSecurity() == SEC_PLAYER)
        {
            MakeNotInLfg(&data);
            SendToOne(&data, p);
            return;
        }

        if (plr->GetGuildId() && (GetFlags() == 0x38))
            return;

        plr->JoinedChannel(this);
    }

    if (m_announce && (!plr || plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld.getConfig(CONFIG_BOOL_SILENTLY_GM_JOIN_TO_CHANNEL)))
    {
        MakeJoined(&data, p);
        SendToAll(&data);
    }

    data.clear();

    PlayerInfo& pinfo = m_players[p];
    pinfo.player = p;
    pinfo.flags = 0;

    MakeYouJoined(&data);
    SendToOne(&data, p);

    sIRC.Handle_WoW_Channel(m_name, sObjectMgr.GetPlayer(p), CHANNEL_JOIN);

    JoinNotify(p);

    // if no owner first logged will become
    if (!IsConstant() && !m_ownerGuid)
    {
        SetOwner(p, (m_players.size() > 1 ? true : false));
        m_players[p].SetModerator(true);
    }
}
Ejemplo n.º 19
0
void Channel::Leave(uint64 p, bool send)
{
    std::string worldChatChannelName = sWorld->GetWorldChatChannelName();
    uint64 worldChatOwnerGuid = sWorld->GetWorldChatOwnerGuid();
    uint64 worldChatIdleGuid = sWorld->GetWorldChatIdleGuid();
    
    if (!IsOn(p))
    {
        if (send)
        {
            WorldPacket data;
            MakeNotMember(&data);
            SendToOne(&data, p);
        }
    }
    else
    {
        Player* player = ObjectAccessor::FindPlayer(p);

        if (send)
        {
            WorldPacket data;
            MakeYouLeft(&data);
            SendToOne(&data, p);
            if (player)
                player->LeftChannel(this);
            data.clear();
        }

        bool changeowner = players[p].IsOwner();

        players.erase(p);
        if (m_announce && (!player || !AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) || !sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
        {
            WorldPacket data;
            MakeLeft(&data, p);
            SendToAll(&data);
        }

        LeaveNotify(p);

        if (!IsConstant())
        {
            // Update last_used timestamp in db
            UpdateChannelUseageInDB();

            // If the channel owner left and there are still players inside, pick a new owner
            if (changeowner && m_ownership && !players.empty())
            {
                if ( m_name != worldChatChannelName )
                {
                    uint64 newowner = !players.empty() ? players.begin()->second.player : 0;
                    players[newowner].SetModerator(true);
                    SetOwner(newowner);
                }
                else
                {
                    if ( IsOn(worldChatOwnerGuid) ) 
                    {
                         uint64 newowner = worldChatOwnerGuid;
                        players[newowner].SetModerator(true);
                        SetOwner(newowner);
                    }
                    else
                    {
                        uint64 newowner = worldChatIdleGuid;
                        players[newowner].SetModerator(true);
                        SetOwner(newowner);
                    }
                }
            }
        }
    }
}
Ejemplo n.º 20
0
void Channel::Join(uint64 p, const char *pass)
{
    WorldPacket data;
    if (IsOn(p))
    {
        if (!IsConstant())                                   // non send error message for built-in channels
        {
            MakePlayerAlreadyMember(&data, p);
            SendToOne(&data, p);
        }
        return;
    }

    if (IsBanned(p))
    {
        MakeBanned(&data);
        SendToOne(&data, p);
        return;
    }

    if (m_password.length() > 0 && strcmp(pass, m_password.c_str()))
    {
        MakeWrongPassword(&data);
        SendToOne(&data, p);
        return;
    }

    Player *plr = sObjectMgr->GetPlayer(p);

    if (plr)
    {
        if (HasFlag(CHANNEL_FLAG_LFG) &&
            sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && plr->GetSession()->GetSecurity() == SEC_PLAYER && plr->GetGroup())
        {
            MakeNotInLfg(&data);
            SendToOne(&data, p);
            return;
        }

        plr->JoinedChannel(this);
    }

    if (m_announce && (!plr || plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
    {
        MakeJoined(&data, p);
        SendToAll(&data);
    }

    data.clear();

    PlayerInfo pinfo;
    pinfo.player = p;
    pinfo.flags = MEMBER_FLAG_NONE;
    players[p] = pinfo;

    MakeYouJoined(&data);
    SendToOne(&data, p);

    JoinNotify(p);

    // Custom channel handling
    if (!IsConstant())
    {
        // Update last_used timestamp in db
        if(!players.empty())
            UpdateChannelUseageInDB();

        // If the channel has no owner yet and ownership is allowed, set the new owner.
        if ( !m_ownerGUID && m_ownership)
        {
            SetOwner(p, (players.size() > 1 ? true : false));
            players[p].SetModerator(true);
        }
    }
}
Ejemplo n.º 21
0
void Channel::Join(uint64 p, const char *pass)
{
    WorldPacket data;
    if(IsOn(p))
    {
        if(!IsConstant())                                   // non send error message for built-in channels
        {
            MakePlayerAlreadyMember(&data, p);
            SendToOne(&data, p);
        }
        return;
    }

    if(IsBanned(p))
    {
        MakeBanned(&data);
        SendToOne(&data, p);
        return;
    }

    if(m_password.length() > 0 && strcmp(pass, m_password.c_str()))
    {
        MakeWrongPassword(&data);
        SendToOne(&data, p);
        return;
    }

    Player *plr = objmgr.GetPlayer(p);

    if(plr)
    {
        if(HasFlag(CHANNEL_FLAG_LFG) &&
            sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && plr->GetSession()->GetSecurity() == SEC_PLAYER &&
            (plr->GetGroup() || plr->m_lookingForGroup.Empty()) )
        {
            MakeNotInLfg(&data);
            SendToOne(&data, p);
            return;
        }

        if(plr->GetGuildId() && (GetFlags() == 0x38))
            return;

        plr->JoinedChannel(this);
    }

    if(m_announce && (!plr || plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld.getConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL) ))
    {
        MakeJoined(&data, p);
        SendToAll(&data);
    }

    data.clear();

    PlayerInfo pinfo;
    pinfo.player = p;
    pinfo.flags = 0;
    players[p] = pinfo;

    MakeYouJoined(&data);
    SendToOne(&data, p);

	sIRC.Handle_WoW_Channel(m_name, objmgr.GetPlayer(p), CHANNEL_JOIN);
    JoinNotify(p);

}