C++ WorldPacket::SetOpcode方法代码示例

    static bool HandleGMFlyCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;

        Player *target =  handler->getSelectedPlayer();
        if (!target)
            target = handler->GetSession()->GetPlayer();

        WorldPacket data;
        if (strncmp(args, "on", 3) == 0)
            data.SetOpcode(UNKNOWN_OPCODE);
        else if (strncmp(args, "off", 4) == 0)
            data.SetOpcode(UNKNOWN_OPCODE);
        else
        {
            handler->SendSysMessage(LANG_USE_BOL);
            return false;
        }
        data.append(target->GetPackGUID());
        data << uint32(0);                                      // unknown
        target->SendMessageToSet(&data, true);
        handler->PSendSysMessage(LANG_COMMAND_FLYMODE_STATUS, handler->GetNameLink(target).c_str(), args);
        return true;
    }

void Pet::SendNullSpellsToOwner()
{
    WorldPacket data;
    data.SetOpcode(SMSG_PET_SPELLS);
    data << uint64(0);
    m_Owner->GetSession()->SendPacket(&data);
}

void WorldSocket::OutPacket(uint16 opcode, size_t len, const void* data)
{
	OUTPACKET_RESULT res;
	if( (len + 10) > WORLDSOCKET_SENDBUF_SIZE )
	{
		printf("WARNING: Tried to send a packet of %u bytes (which is too large) to a socket. Opcode was: %u (0x%03X)\n", (unsigned int)len, (unsigned int)opcode, (unsigned int)opcode);
		return;
	}

	res = _OutPacket(opcode, len, data);
	if(res == OUTPACKET_RESULT_SUCCESS)
		return;

	if(res == OUTPACKET_RESULT_NO_ROOM_IN_BUFFER)
	{
		/* queue the packet */
		queueLock.Acquire();
		//WorldPacket * pck = new WorldPacket(opcode, len);
		WorldPacket * pck = g_bufferPool.Allocate(len);
		pck->SetOpcode(opcode);
		if(len) pck->append((const uint8*)data, len);
		_queue.Push(pck);
		queueLock.Release();
	}
}

void CGroup::PackGroupMemberInfo(uint32_t userid, WorldPacket &info)
{
	info.SetOpcode(CMD_SC_GROUP_MEMBER_INFO);
	std::map<uint32_t, SGroupMember>::iterator it = m_mapUserGroup.find(userid);
	std::map<uint32_t, uint8_t>::iterator itmission;
	if (it != m_mapUserGroup.end())
	{
		info << (it->second).dwUserId;
		info << (it->second).dwCredit;
		info << (it->second).byPosion;	

		info << (uint32_t)(it->second).mapMission.size();
		for (itmission = (it->second).mapMission.begin(); itmission != (it->second).mapMission.end(); itmission++)
		{
			info << itmission->first;
			info << itmission->second;
		}

		info << (it->second).dwCreditSupport;
	}
	else
	{
		info << (uint32_t) 0;
		info << (uint32_t) 0;
		info << (uint8_t) 0;

		info << (uint32_t) 0;

		info << (uint32_t) 0;
	}
}	

void SubGroup::Disband(bool bRemoveGroup)
{
	WorldPacket data;
	data.SetOpcode(SMSG_GROUP_DESTROYED);

	WorldPacket data2;
	data2.SetOpcode(SMSG_PARTY_COMMAND_RESULT);
	data2 << uint32(2) << uint8(0) << uint32(0);	// you leave the group

	GroupMembersSet::iterator itr = m_GroupMembers.begin();
	for(; itr != m_GroupMembers.end(); ++itr)
	{
		(*itr)->GetSession()->SendPacket(&data);
		(*itr)->GetSession()->SendPacket(&data2);
		(*itr)->SetSubGroup(0);
		m_Parent->m_MemberCount--;

		if(bRemoveGroup)
		{
			(*itr)->SetGroup(NULL);
			m_Parent->SendNullUpdate((*itr));
		}
		/* remove SoulStones if caster and reciever are not the same player */
		if((*itr)->SoulStoneReciever && (*itr)->SoulStoneReciever!=(*itr)->GetGUID())
			(*itr)->removeSoulStone();
	}

	m_Parent->m_SubGroups[m_Id] = NULL;
	delete this;
}

void CGroup::PackGroupInfo(WorldPacket &pkg)
{
	std::vector<unsigned char> vecEnums;
	vecEnums.push_back(E_GROUP_dwId);
	vecEnums.push_back(E_GROUP_strName);
	vecEnums.push_back(E_GROUP_dwCreateId);
	vecEnums.push_back(E_GROUP_strCreateName);
	vecEnums.push_back(E_GROUP_dwCredit);
	vecEnums.push_back(E_GROUP_wLevel);
	vecEnums.push_back(E_GROUP_wPersionLimit);
	vecEnums.push_back(E_GROUP_byPosion1Limit);
	vecEnums.push_back(E_GROUP_byPosion2Limit);
	vecEnums.push_back(E_GROUP_byPosion3Limit);
	vecEnums.push_back(E_GROUP_byPosion4Limit);
	vecEnums.push_back(E_GROUP_vecPosion1Persion);
	vecEnums.push_back(E_GROUP_vecPosion1PersionStr);
	vecEnums.push_back(E_GROUP_vecPosion2Persion);
	vecEnums.push_back(E_GROUP_vecPosion3Persion);
	vecEnums.push_back(E_GROUP_vecPosion4Persion);
	vecEnums.push_back(E_GROUP_vecPosion5Persion);
	vecEnums.push_back(E_GROUP_wPersionNumber);
	vecEnums.push_back(E_GROUP_strNotice);
	vecEnums.push_back(E_GROUP_dwNeedCredit);
	vecEnums.push_back(E_GROUP_dwCreditLimit);
	vecEnums.push_back(E_GROUP_dwMissionFlushTime);
	vecEnums.push_back(E_GROUP_byMissionFlushNumber);
	vecEnums.push_back(E_GROUP_dwMissionFlushPoint);

	pkg.SetOpcode(CMD_SC_GROUP_INFO);
	saveDataNeed(pkg, vecEnums);
	clearDirtyFlag();
}

    void PacketBuilder::WriteCommonMonsterMovePart(const MoveSpline& move_spline, WorldPacket& data)
    {
        MoveSplineFlag splineflags = move_spline.splineflags;

        if (move_spline.transportGuid)
        {
            //DEBUG_LOG("Setting transport opcode for %s", move_spline.transport->GetGuidStr().c_str());
            data.SetOpcode(SMSG_MONSTER_MOVE_TRANSPORT);
            data << PackedGuid(move_spline.transportGuid);
            data << uint8(move_spline.transportSeat);
            data << uint8(0);
            data << (Vector3)move_spline.transportPos;
        }
        else
        {
            data << uint8(0);
            data << move_spline.spline.getPoint(move_spline.spline.first());
        }

        data << move_spline.GetId();

        switch(splineflags & MoveSplineFlag::Mask_Final_Facing)
        {
            default:
                data << uint8(MonsterMoveNormal);
                break;
            case MoveSplineFlag::Final_Target:
                data << uint8(MonsterMoveFacingTarget);
                data << move_spline.facing.target;
                break;
            case MoveSplineFlag::Final_Angle:
                data << uint8(MonsterMoveFacingAngle);
                data << NormalizeOrientation(move_spline.facing.angle);
                break;
            case MoveSplineFlag::Final_Point:
                data << uint8(MonsterMoveFacingSpot);
                data << move_spline.facing.f.x << move_spline.facing.f.y << move_spline.facing.f.z;
                break;
        }

        // add fake Enter_Cycle flag - needed for client-side cyclic movement (client will erase first spline vertex after first cycle done)
        splineflags.enter_cycle = move_spline.isCyclic();
        data << uint32(splineflags & ~MoveSplineFlag::Mask_No_Monster_Move);

        if (splineflags.animation)
        {
            data << splineflags.getAnimationId();
            data << move_spline.effect_start_time;
        }

        data << move_spline.Duration();

        if (splineflags.parabolic)
        {
            data << move_spline.vertical_acceleration;
            data << move_spline.effect_start_time;
        }
    }

void Channel::RequestList(std::string ch)
{
	if(!IsOnChannel(ch))
		logdebug("Requesting list of not joined channel '%s'",ch.c_str());
	WorldPacket wp;
	wp.SetOpcode(CMSG_CHANNEL_LIST);
	wp << ch;
	_worldSession->SendWorldPacket(wp);
}

void NetManager::cs_GetSchedule()
{
	WorldPacket packet;
	packet.clear();
	packet.SetOpcode(MSG_CS_GET_SCHEDULE);
	packet.AppendPacketString<uint8>(Player::getSingleton().getID());
	packet.SetLength(packet.size());
	sSocketMgr.SendPacket(LIFE_SOCKET_ID, &packet);
}

void LootRoll::Finalize()
{
    // this we will have to finalize with groups types.. for now
    // we'll just assume need before greed. person with highest roll
    // in need gets the item.

    uint32 highest = 0;
    int8 hightype = -1;
    Player *player = NULL;

    for(std::map<Player*, uint32>::iterator itr = NeedRolls.begin(); itr != NeedRolls.end(); ++itr)
    {
        if(itr->second > highest)
        {
            highest = itr->second;
            player = itr->first;
            hightype = NEED;
        }
    }

    if(highest == 0)
    {
        for(std::map<Player*, uint32>::iterator itr = GreedRolls.begin(); itr != GreedRolls.end(); ++itr)
        {
            if(itr->second > highest)
            {
                highest = itr->second;
                player = itr->first;
                hightype = GREED;
            }
        }
    }

    if(!player)
    {
        delete this;
        return;
    }

    WorldPacket data(34);
    data.SetOpcode(SMSG_LOOT_ROLL_WON);
    data << _guid << _slotid << _itemid << _itemunk1 << _itemunk2;
    data << player->GetGUID() << uint8(highest) << uint8(hightype);
    if(player->InGroup())
        player->GetGroup()->SendPacketToAll(&data);
    else
        player->GetSession()->SendPacket(&data);

    // Distribute the item.. yes i am lazy:D
    WorldPacket *tmp = new WorldPacket(1);
    tmp->SetOpcode(CMSG_AUTOSTORE_LOOT_ITEM);
    *tmp << uint8(_slotid);
    player->GetSession()->QueuePacket(tmp);

    delete this;
}

void WorldSession::SendEmote(uint32 id)
{
    if(!_logged)
        return;
    WorldPacket packet;
    int32 variation = 0; // randomized usually
    packet << id << (uint32)variation << GetMyChar()->GetTarget();
    packet.SetOpcode(CMSG_TEXT_EMOTE);
    SendWorldPacket(packet);
}

void WorldSession::SendPing(uint32 ping)
{
    if(!_logged)
        return;
    WorldPacket packet;
    packet << ping;
    packet << GetLagMS();
    packet.SetOpcode(CMSG_PING);
    SendWorldPacket(packet);
}

void WorldSession::SendQueryPlayerName(uint64 guid)
{
    if((!_logged) || guid==0)
        return;
    WorldPacket packet;
    packet << guid;
    packet.SetOpcode(CMSG_NAME_QUERY);
    SendWorldPacket(packet);
    // to prevent opcode spam, we need to make a list with already requested names
}

void NetManager::cs_DominoDownloadTilemap()
{
	WorldPacket packet;
	packet.clear();
	packet.SetOpcode(MSG_CS_DOMINO_DOWNLOAD_TILEMAP);
	packet.AppendPacketString<uint8>(Player::getSingleton().getID());
	packet << (int)1;
	packet.SetLength(packet.size());
	sSocketMgr.SendPacket(LIFE_SOCKET_ID, &packet);
}

void WorldSession::SendQueryItem(uint32 entry, uint64 guid) // is it a guid? not sure
{
    if(objmgr.ItemNonExistent(entry))
    {
        logdebug("Skipped query of item %u (was marked as nonexistent before)",entry);
        return;
    }
    logdebug("Sending Item query, id=%u",entry);
    WorldPacket packet;
    packet << entry << guid;
    packet.SetOpcode(CMSG_ITEM_QUERY_SINGLE);
    SendWorldPacket(packet);
}