Exemple #1
0
void PacketParser(SOCKET sck, const char *Packet)
{
	switch (Packet[0])
	{
	// Movement packet.
	case PacketHeaders.MovementPacket:
		{
			MOVEMENTPACKET *mp = (MOVEMENTPACKET*)Packet;
			cout << "Mov*" << "ID:" << mp->ID << "|" << "MID:" << mp->MapID << "|" << "X:" << mp->XPos << "|" << "Y:" << mp->YPos << endl;
			BroadcastPacket(Packet, sizeof(MOVEMENTPACKET));
		}
		break;

	// Chat packet
	case PacketHeaders.ChatPacket:
		{
			CHATPACKET *cp = (CHATPACKET*)Packet;
			cout << "Chat*"<< cp->ID << "||" << cp->Text << endl;
			BroadcastPacket(Packet, cp->Length);
		}
		break;

	// Login packet
	case PacketHeaders.LoginPacket:
		{
			LOGINPACKET *lp = (LOGINPACKET*)Packet;
			cout << "Login*" << lp->Username << " : " << lp->Password << endl;

			stringstream querystring;
			querystring << "SELECT * FROM (`Users`) WHERE (`Username`='" << lp->Username << "' AND `Password`='" << lp->Password << "') LIMIT 1";
			mysqlpp::Connection con;
			con.connect(0, "localhost", "root", "", 3306);
			con.select_db("moonlightfrost");
			mysqlpp::Query qry(con.query(querystring.str()));
			mysqlpp::StoreQueryResult qr(qry.store());
			con.disconnect();

			if ( qr.num_rows() == 0 )
			{
				lp->UserID = 0;
				send(sck, (char *)lp, sizeof(LOGINPACKET), 0);
			}
			else
			{
				lp->UserID = atol(qr[0]["ID"].c_str());
				send(sck, (char *)lp, sizeof(LOGINPACKET), 0);
			}
		}
		break;

	default:
		{
			printf("WARNING: Recieved packet structure not recognized. Header: %s \n", (int)((char)Packet[0]));
		}
		break;
	}
}
Exemple #2
0
void NetServer::SendDriversReadyPacket()
{
	
	NetMutexData *pNData = LockNetworkData();

	int rsize = pNData->m_vecReadyStatus.size();

        PackedBuffer msg;

        try
        {
                msg.pack_ubyte(ALLDRIVERREADY_PACKET);
                msg.pack_int(rsize);
                for (int i = 0; i < rsize; i++)
                {
                        msg.pack_int(pNData->m_vecReadyStatus[i]);
                }
        }
        catch (PackedBufferException &e)
        {
                GfLogFatal("SendDriversReadyPacket: packed buffer error\n");
        }
        GfLogTrace("SendDriversReadyPacket: packed data length=%d\n",
                msg.length());

	UnlockNetworkData();

	ENetPacket * pPacket = enet_packet_create (msg.buffer(), 
                                              msg.length(), 
                                              ENET_PACKET_FLAG_RELIABLE);

	BroadcastPacket(pPacket,RELIABLECHANNEL);
	m_bRefreshDisplay = true;
}
Exemple #3
0
void NetServer::SendStartTimePacket(int &startTime)
{
	//Wait RACESTARTDELEAY seconds to start race
	m_racestarttime = GfTimeClock()+RACESTARTDELEAY;

        PackedBuffer msg;

        try
        {
                msg.pack_ubyte(RACESTARTTIME_PACKET);
                msg.pack_double(m_racestarttime);
        }
        catch (PackedBufferException &e)
        {
                GfLogFatal("SendStartTimePacket: packed buffer error\n");
        }
        GfLogTrace("SendStartTimePacket: packed data length=%d\n",
                msg.length());

	ENetPacket * pPacket = enet_packet_create (msg.buffer(), 
                                              msg.length(), 
                                              ENET_PACKET_FLAG_RELIABLE);

	BroadcastPacket(pPacket,RELIABLECHANNEL);

	GfLogInfo("Server Start time is %lf\n",m_racestarttime);
}
Exemple #4
0
//Here you are Xavier a dynamic weather packet
void NetServer::SendWeatherPacket()
{
	GfLogTrace("Sending Weather Packet\n");
	
        PackedBuffer msg;

        try
        {
                msg.pack_ubyte(WEATHERCHANGE_PACKET);
                //TODO add weather data here
        }
        catch (PackedBufferException &e)
        {
                GfLogFatal("SendWeatherPacket: packed buffer error\n");
        }
        GfLogTrace("SendWeatherPacket: packed data length=%d\n",
                msg.length());

	ENetPacket *pWeatherPacket = enet_packet_create(msg.buffer(),
                msg.length(),
                ENET_PACKET_FLAG_RELIABLE);
	
	
	BroadcastPacket(pWeatherPacket,RELIABLECHANNEL);
}
Exemple #5
0
void Guild::BroadcastEvent(GuildEvents event, ObjectGuid guid, char const* str1 /*=NULL*/, char const* str2 /*=NULL*/, char const* str3 /*=NULL*/)
{
    uint8 strCount = !str1 ? 0 : (!str2 ? 1 : (!str3 ? 2 : 3));

    WorldPacket data(SMSG_GUILD_EVENT, 1 + 1 + 1 * strCount + (guid.IsEmpty() ? 0 : 8));
    data << uint8(event);
    data << uint8(strCount);

    if (str3)
    {
        data << str1;
        data << str2;
        data << str3;
    }
    else if (str2)
    {
        data << str1;
        data << str2;
    }
    else if (str1)
        { data << str1; }

    if (!guid.IsEmpty())
        { data << guid; }

    BroadcastPacket(&data);

    DEBUG_LOG("WORLD: Sent SMSG_GUILD_EVENT");
}
Exemple #6
0
void NetServer::SendFinishTimePacket()
{
	GfLogTrace("Sending finish Time Packet\n");
	
	NetMutexData *pNData = LockNetworkData();
	double time = pNData->m_finishTime;
	UnlockNetworkData();

	GfLogInfo("Server finish time is %lf\n",time);
        
        PackedBuffer msg;

        try
        {
                msg.pack_ubyte(FINISHTIME_PACKET);
                msg.pack_double(time);
        }
        catch (PackedBufferException &e)
        {
                GfLogFatal("SendFinishTimePacket: packed buffer error\n");
        }
        GfLogTrace("SendFinishTimePacket: packed data length=%d\n",
                msg.length());

	ENetPacket * pPacket = enet_packet_create (msg.buffer(), 
                                              msg.length(), 
                                              ENET_PACKET_FLAG_RELIABLE);
	BroadcastPacket(pPacket,RELIABLECHANNEL);
}
Exemple #7
0
void ArenaTeam::BroadcastEvent(ArenaTeamEvents event, ObjectGuid guid, char const* str1 /*=NULL*/, char const* str2 /*=NULL*/, char const* str3 /*=NULL*/)
{
    uint8 strCount = !str1 ? 0 : (!str2 ? 1 : (!str3 ? 2 : 3));

    WorldPacket data(SMSG_ARENA_TEAM_EVENT, 1 + 1 + 1*strCount + (!guid ? 0 : 8));
    data << uint8(event);
    data << uint8(strCount);

    if (str3)
    {
        data << str1;
        data << str2;
        data << str3;
    }
    else if (str2)
    {
        data << str1;
        data << str2;
    }
    else if (str1)
        data << str1;

    if (guid)
        data << ObjectGuid(guid);

    BroadcastPacket(&data);

    DEBUG_LOG("WORLD: Sent SMSG_ARENA_TEAM_EVENT");
}
Exemple #8
0
void Guild::BroadcastEvent(GuildEvents event, uint64 guid, uint8 strCount, std::string str1, std::string str2, std::string str3)
{
    WorldPacket data(SMSG_GUILD_EVENT, 1+1+(guid ? 8 : 0));
    data << uint8(event);
    data << uint8(strCount);

    switch(strCount)
    {
    case 0:
        break;
    case 1:
        data << str1;
        break;
    case 2:
        data << str1 << str2;
        break;
    case 3:
        data << str1 << str2 << str3;
        break;
    default:
        sLog.outError("Guild::BroadcastEvent: incorrect strings count %u!", strCount);
        break;
    }

    if(guid)
        data << uint64(guid);

    BroadcastPacket(&data);

    sLog.outDebug("WORLD: Sent SMSG_GUILD_EVENT");
}
void ArenaTeam::BroadcastEvent(ArenaTeamEvents event, ObjectGuid guid, uint8 strCount, std::string const& str1, std::string const& str2, std::string const& str3)
{
    WorldPacket data(SMSG_ARENA_TEAM_EVENT, 1+1+1);
    data << uint8(event);
    data << uint8(strCount);
    switch (strCount)
    {
        case 0:
            break;
        case 1:
            data << str1;
            break;
        case 2:
            data << str1 << str2;
            break;
        case 3:
            data << str1 << str2 << str3;
            break;
        default:
            TC_LOG_ERROR("bg.arena", "Unhandled strCount %u in ArenaTeam::BroadcastEvent", strCount);
            return;
    }

    if (guid)
        data << uint64(guid);

    BroadcastPacket(&data);

    TC_LOG_DEBUG("network", "WORLD: Sent SMSG_ARENA_TEAM_EVENT");
}
Exemple #10
0
void ArenaTeam::Disband(WorldSession *session)
{
    // event
    WorldPacket data;
    session->BuildArenaTeamEventPacket(&data, ERR_ARENA_TEAM_DISBANDED_S, 2, session->GetPlayerName(), GetName(), "");
    BroadcastPacket(&data);

    uint32 count = members.size();
    uint64 *memberGuids = new uint64[count];

    MemberList::iterator itr;
    uint32 i=0;
    for(itr = members.begin(); itr != members.end(); itr++)
    {
        memberGuids[i] = itr->guid;
        ++i;
    }

    for(uint32 j = 0; j < count; j++)
        DelMember(memberGuids[j]);
    delete[] memberGuids;

    CharacterDatabase.BeginTransaction();
    CharacterDatabase.PExecute("DELETE FROM arena_team WHERE arenateamid = '%u'", Id);
    CharacterDatabase.PExecute("DELETE FROM arena_team_stats WHERE arenateamid = '%u'", Id);
    CharacterDatabase.CommitTransaction();
    objmgr.RemoveArenaTeam(this);
}
void ArenaTeam::BroadcastEvent(ArenaTeamEvents event, uint64 guid, uint8 strCount, std::string str1, std::string str2, std::string str3)
{
    WorldPacket data(SMSG_ARENA_TEAM_EVENT, 1+1+1);
    data << uint8(event);
    data << uint8(strCount);
    switch (strCount)
    {
        case 0:
            break;
        case 1:
            data << str1;
            break;
        case 2:
            data << str1 << str2;
            break;
        case 3:
            data << str1 << str2 << str3;
            break;
        default:
            sLog->outError("Unhandled strCount %u in ArenaTeam::BroadcastEvent", strCount);
            return;
    }

    if (guid)
        data << uint64(guid);

    BroadcastPacket(&data);

    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Sent SMSG_ARENA_TEAM_EVENT");
}
Exemple #12
0
void OPvPWintergrasp::SendInitWorldStatesTo(Player *player) const
{
    WorldPacket data(SMSG_INIT_WORLD_STATES, (4+4+4+2+(m_buildingStates.size()*8)));
    data << uint32(571);
    data << uint32(ZONE_WINTERGRASP);
    data << uint32(0);
    data << uint16(4+5+4+m_buildingStates.size());

    data << uint32(3803) << uint32(m_defender == TEAM_ALLIANCE ? 1 : 0);
    data << uint32(3802) << uint32(m_defender != TEAM_ALLIANCE ? 1 : 0);
    data << uint32(3801) << uint32(m_wartime ? 0 : 1);
    data << uint32(3710) << uint32(m_wartime ? 1 : 0);

    for (uint32 i = 0; i < 5; ++i)
        data << ClockWorldState[i] << m_clock[i];

    data << uint32(3490) << uint32(m_vehicles[TEAM_HORDE].size());
    data << uint32(3491) << m_workshopCount[TEAM_HORDE] * MAX_VEHICLE_PER_WORKSHOP;
    data << uint32(3680) << uint32(m_vehicles[TEAM_ALLIANCE].size());
    data << uint32(3681) << m_workshopCount[TEAM_ALLIANCE] * MAX_VEHICLE_PER_WORKSHOP;

    for (BuildingStateMap::const_iterator itr = m_buildingStates.begin(); itr != m_buildingStates.end(); ++itr)
        itr->second->FillData(data);

    if (player)
        player->GetSession()->SendPacket(&data);
    else
        BroadcastPacket(data);
}
Exemple #13
0
// Removes a player from the battle
void _Battle::RemoveObject(_Object *RemoveObject) {

	// Remove action results
	for(auto Iterator = ActionResults.begin(); Iterator != ActionResults.end(); ) {
		_ActionResult &ActionResult = *Iterator;
		if(ActionResult.Source.Object == RemoveObject || ActionResult.Target.Object == RemoveObject) {
			Iterator = ActionResults.erase(Iterator);
		}
		else
			++Iterator;
	}

	// Remove objects
	for(auto Iterator = Objects.begin(); Iterator != Objects.end(); ++Iterator) {
		_Object *Object = *Iterator;
		if(Object == RemoveObject) {

			// Broadcast object leaving
			if(Server) {
				ae::_Buffer Packet;
				Packet.Write<PacketType>(PacketType::BATTLE_LEAVE);
				Packet.Write<ae::NetworkIDType>(Object->NetworkID);
				BroadcastPacket(Packet);
			}

			SideCount[Object->Fighter->BattleSide]--;
			Object->StopBattle();
			Objects.erase(Iterator);
			return;
		}
	}
}
Exemple #14
0
//Send a file to clients
//Do not use this to send large files
//In future maybe change to TCP based
//64k file size limit
void NetServer::SendFilePacket(const char *pszFile)
{
	char filepath[255];
	sprintf(filepath, "%s%s", GfLocalDir(), pszFile);
	
	GfLogTrace("Sending file packet: File- %s\n",filepath);

	FILE *pFile = fopen(filepath,"rb");
	if (!pFile)
		return;

	char buf[0xffff];
	size_t size;
	size = fread( buf, 1, 0xffff, pFile );

	//File is to big
	if (!feof(pFile))
	{
		fclose(pFile);
		assert(false);
		return;
	}

	fclose(pFile);
	unsigned int filesize = size;
	GfLogTrace("Server file size %u\n",filesize);

	short namelen = strlen(pszFile);

        /* On 64 bit systems, the following calculates a buffer size that is
         * bigger than necessary, but that is safe. Better too big than too
         * small.
         */
        size_t bufsize = 1 + sizeof namelen + namelen +
                sizeof filesize + filesize;

        PackedBuffer msg(bufsize);

        try
        {
                msg.pack_ubyte(FILE_PACKET);
                msg.pack_short(namelen);
                msg.pack_string(pszFile, namelen);
                msg.pack_uint(filesize);
                msg.pack_string(buf, size);
        }
        catch (PackedBufferException &e)
        {
                GfLogFatal("SendFilePacket: packed buffer error\n");
        }
        GfLogTrace("SendFilePacket: packed data length=%d\n",
                msg.length());

	ENetPacket * pPacket = enet_packet_create (msg.buffer(), 
                                              msg.length(), 
                                              ENET_PACKET_FLAG_RELIABLE);
	
	BroadcastPacket(pPacket,RELIABLECHANNEL);
}
Exemple #15
0
uint32 Group::RemoveMember(ObjectGuid guid, uint8 method)
{
    //Playerbot mod - if master leaves group, all bots leave group
    {
        Player* const player = sObjectMgr.GetPlayer(guid);
        if (player && player->GetPlayerbotMgr())
            player->GetPlayerbotMgr()->RemoveAllBotsFromGroup();
    }
    //END Playerbot mod

    // remove member and change leader (if need) only if strong more 2 members _before_ member remove
    if (GetMembersCount() > uint32(isBGGroup() ? 1 : 2))    // in BG group case allow 1 members group
    {
        bool leaderChanged = _removeMember(guid);

        if (Player* player = sObjectMgr.GetPlayer(guid))
        {
            // quest related GO state dependent from raid membership
            if (isRaidGroup())
                player->UpdateForQuestWorldObjects();

            WorldPacket data;

            if (method == 1)
            {
                data.Initialize(SMSG_GROUP_UNINVITE, 0);
                player->GetSession()->SendPacket(&data);
            }

            // we already removed player from group and in player->GetGroup() is his original group!
            if (Group* group = player->GetGroup())
            {
                group->SendUpdate();
            }
            else
            {
                data.Initialize(SMSG_GROUP_LIST, 24);
                data << uint64(0) << uint64(0) << uint64(0);
                player->GetSession()->SendPacket(&data);
            }

            _homebindIfInstance(player);
        }

        if (leaderChanged)
        {
            WorldPacket data(SMSG_GROUP_SET_LEADER, (m_memberSlots.front().name.size() + 1));
            data << m_memberSlots.front().name;
            BroadcastPacket(&data, true);
        }

        SendUpdate();
    }
    // if group before remove <= 2 disband it
    else
        Disband(true);

    return m_memberSlots.size();
}
Exemple #16
0
OVERLAY void doexit(void)
{
  packet_header_t packet;

  // Send "downed" packet
  packet.type = PKT_DOWN; 
  packet.tic = 0; // Clients should not need the tic number, can't see a use for it
  BroadcastPacket(&packet, sizeof packet);
}
Exemple #17
0
void Group::ChangeLeader(const uint64 &guid)
{
    _setLeader(guid);

    WorldPacket data(SMSG_GROUP_SET_LEADER, (m_members[_getMemberIndex(guid)].name.size()+1));
    data << m_members[_getMemberIndex(guid)].name;
    BroadcastPacket(&data);
    SendUpdate();
}
Exemple #18
0
//Remove disconnected player from race track
void NetServer::RemovePlayerFromRace(unsigned int idx)
{
	GfLogTrace("Removing disconnected player\n");
	std::vector<CarStatus> vecCarStatus;
	double time = 0.0;

	int startRank = GetDriverStartRank(idx);
	CarStatus cstatus;
	cstatus.topSpeed = -1.0;
	cstatus.fuel = -1.0;
	cstatus.startRank = startRank;
	cstatus.dammage = -1;
	cstatus.state = RM_CAR_STATE_ELIMINATED;
	cstatus.time = m_currentTime;
	
	NetMutexData *pNData = LockNetworkData();
	pNData->m_vecCarStatus.push_back(cstatus);
	UnlockNetworkData();

	vecCarStatus.push_back(cstatus);

	time = m_currentTime;

	int iNumCars = vecCarStatus.size();

        PackedBuffer msg;

        try
        {
                msg.pack_ubyte(CARSTATUS_PACKET);
                msg.pack_double(time);
                msg.pack_int(iNumCars);
                for (int i=0;i<iNumCars;i++)
                {
                        msg.pack_float(vecCarStatus[i].topSpeed);
                        msg.pack_int(vecCarStatus[i].state);
                        msg.pack_int(vecCarStatus[i].startRank);
                        msg.pack_int(vecCarStatus[i].dammage);
                        msg.pack_float(vecCarStatus[i].fuel);
                }
        }
        catch (PackedBufferException &e)
        {
                GfLogFatal("RemovePlayerFromRace: packed buffer error\n");
        }
        GfLogTrace("RemovePlayerFromRace: packed data length=%d\n",
                msg.length());

	ENetPacket * pPacket = enet_packet_create (msg.buffer(), 
                                              msg.length(), 
                                              ENET_PACKET_FLAG_RELIABLE);

	BroadcastPacket(pPacket,RELIABLECHANNEL);
}
Exemple #19
0
void Guild::DisplayGuildBankMoneyUpdate()
{
    WorldPacket data(SMSG_GUILD_BANK_LIST, 8+1+4+1+1);

    data << uint64(GetGuildBankMoney());
    data << uint8(0);                                       // TabId, default 0
    data << uint32(0);                                      // slot withdrow, default 0
    data << uint8(0);                                       // Tell client this is a tab content packet
    data << uint8(0);                                       // not send items
    BroadcastPacket(&data);

    sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
}
Exemple #20
0
void Group::ChangeLeader(ObjectGuid guid)
{
    member_citerator slot = _getMemberCSlot(guid);
    if (slot == m_memberSlots.end())
        return;

    _setLeader(guid);

    WorldPacket data(SMSG_GROUP_SET_LEADER, slot->name.size() + 1);
    data << slot->name;
    BroadcastPacket(&data, true);
    SendUpdate();
}
Exemple #21
0
void Group::SetTargetIcon(uint8 id, uint64 guid)
{
    if(id >= TARGETICONCOUNT)
        return;

    m_targetIcons[id] = guid;

    WorldPacket data(MSG_RAID_ICON_TARGET, (2+8));
    data << (uint8)0;
    data << id;
    data << guid;
    BroadcastPacket(&data);
}
Exemple #22
0
void doexit(void)
{
  char buf[200];
  packet_header_t packet;

  // Remove any stats file
  sprintf(buf, "lxdoom-game-server-stats.%u", getpid());
  unlink(buf);

  // Send "downed" packet
  packet.type = PKT_DOWN; 
  packet.tic = 0; // Clients should not need the tic number, can't see a use for it
  BroadcastPacket(&packet, sizeof packet);
}
Exemple #23
0
void OPvPWintergrasp::SendInitWorldStatesTo(Player *player)
{
    WorldPacket data(SMSG_INIT_WORLD_STATES, (4+4+4+2+(m_buildingStates.size()*8)));
    data << uint32(571);
    data << uint32(ZONE_WINTERGRASP);
    data << uint32(0);
    data << uint16(m_buildingStates.size());
    for(BuildingStateMap::iterator itr = m_buildingStates.begin(); itr != m_buildingStates.end(); ++itr)
        itr->second->FillData(data);
    if(player)
        player->GetSession()->SendPacket(&data);
    else
        BroadcastPacket(data);
}
Exemple #24
0
void Guild::Roster(WorldSession* session /*= NULL*/)
{
    // we can only guess size
    WorldPacket data(SMSG_GUILD_ROSTER, (4 + MOTD.length() + 1 + GINFO.length() + 1 + 4 + m_Ranks.size() + members.size() * 50));
    data << uint32(members.size());
    data << MOTD;
    data << GINFO;

    data << uint32(m_Ranks.size());
    for (RankList::const_iterator ritr = m_Ranks.begin(); ritr != m_Ranks.end(); ++ritr)
    {
        data << uint32(ritr->Rights);
    }
    for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
    {
        if (Player* pl = ObjectAccessor::FindPlayer(ObjectGuid(HIGHGUID_PLAYER, itr->first)))
        {
            data << pl->GetObjectGuid();
            data << uint8(1);
            data << pl->GetName();
            data << uint32(itr->second.RankId);
            data << uint8(pl->getLevel());
            data << uint8(pl->getClass());
            data << uint8(0);                               // new 2.4.0
            data << uint32(pl->GetZoneId());
            data << itr->second.Pnote;
            data << itr->second.OFFnote;
        }
        else
        {
            data << ObjectGuid(HIGHGUID_PLAYER, itr->first);
            data << uint8(0);
            data << itr->second.Name;
            data << uint32(itr->second.RankId);
            data << uint8(itr->second.Level);
            data << uint8(itr->second.Class);
            data << uint8(0);                               // new 2.4.0
            data << uint32(itr->second.ZoneId);
            data << float(float(time(NULL) - itr->second.LogoutTime) / DAY);
            data << itr->second.Pnote;
            data << itr->second.OFFnote;
        }
    }
    if (session)
        session->SendPacket(&data);
    else
        BroadcastPacket(&data);
    DEBUG_LOG("WORLD: Sent (SMSG_GUILD_ROSTER)");
}
Exemple #25
0
// Adds an object to the map
void _Map::AddObject(_Object *Object) {
	if(Server) {

		// Create packet for the new object
		_Buffer Packet;
		Packet.Write<PacketType>(PacketType::WORLD_CREATEOBJECT);
		Object->SerializeCreate(Packet);

		// Notify other players of the new object
		BroadcastPacket(Packet);
	}

	// Add object to map
	Objects.push_back(Object);
}
Exemple #26
0
void Guild::Roster(WorldSession *session /*= NULL*/)
{
                                                            // we can only guess size
    WorldPacket data(SMSG_GUILD_ROSTER, (4+MOTD.length()+1+GINFO.length()+1+4+m_Ranks.size()*4+members.size()*50));
    data << uint32(members.size());
    data << MOTD;
    data << GINFO;

    data << uint32(m_Ranks.size());
    for (RankList::const_iterator ritr = m_Ranks.begin(); ritr != m_Ranks.end(); ++ritr)
        data << uint32(ritr->Rights);

    for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
    {
        if (Player *pl = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER)))
        {
            data << (uint64)pl->GetGUID();
            data << (uint8)1;
            data << (std::string)pl->GetName();
            data << (uint32)itr->second.RankId;
            data << (uint8)pl->getLevel();
            data << (uint8)pl->getClass();
            data << (uint32)pl->GetZoneId();
            data << itr->second.Pnote;
            data << itr->second.OFFnote;
        }
        else
        {
            data << uint64(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
            data << uint8(0);
            data << itr->second.Name;
            data << uint32(itr->second.RankId);
            data << uint8(itr->second.Level);
            data << uint8(itr->second.Class);
            data << uint32(itr->second.ZoneId);
            data << float(float(time(NULL)-itr->second.LogoutTime) / DAY);
            data << itr->second.Pnote;
            data << itr->second.OFFnote;
        }
    }
    if (session)
        session->SendPacket(&data);
    else
        BroadcastPacket(&data);
    sLog.outDebug( "WORLD: Sent (SMSG_GUILD_ROSTER)" );
}
Exemple #27
0
void broadcast_icon_geometry(
	FvwmWindow *fw, Bool do_force)
{
	rectangle g;
	Bool rc;

	rc = get_visible_icon_geometry(fw, &g);
	if (rc == True && (!IS_ICON_UNMAPPED(fw) || do_force == True))
	{
		BroadcastPacket(
			M_ICON_LOCATION, 7, (long)FW_W(fw),
			(long)FW_W_FRAME(fw), (unsigned long)fw,
			(long)g.x, (long)g.y, (long)g.width, (long)g.height);
	}

	return;
}
Exemple #28
0
// Add an object to the battle
void _Battle::AddObject(_Object *Object, uint8_t Side, bool Join) {
	Object->Character->Battle = this;
	Object->Fighter->BattleSide = Side;
	Object->Fighter->LastTarget[0] = nullptr;
	Object->Fighter->LastTarget[1] = nullptr;
	Object->Character->Targets.clear();
	Object->Character->Action.Unset();
	Object->Fighter->PotentialAction.Unset();
	Object->Character->ResetUIState();
	Object->Fighter->JoinedBattle = Join;
	Object->Fighter->GoldStolen = 0;
	if(Server) {
		Object->Character->GenerateNextBattle();
		Object->Fighter->TurnTimer = ae::GetRandomReal(0, BATTLE_MAX_START_TURNTIMER);

		// Send player join packet to current objects
		if(Join) {
			ae::_Buffer Packet;
			Packet.Write<PacketType>(PacketType::BATTLE_JOIN);
			Object->SerializeBattle(Packet);
			BroadcastPacket(Packet);
		}
	}

	// Count objects and set slots
	SideCount[Side]++;
	Objects.push_back(Object);

	// Object joining on the client
	if(!Server && Join) {

		// Adjust existing battle elements and create new one
		int SideIndex = 0;
		for(auto &AdjustObject : Objects) {
			if(AdjustObject->Fighter->BattleSide == Side) {
				if(AdjustObject == Object)
					CreateBattleElements(SideIndex, AdjustObject);
				else
					AdjustBattleElements(SideIndex, AdjustObject);

				SideIndex++;
			}
		}
	}
}
Exemple #29
0
// Sends object position information to all the clients in the map
void _Map::SendObjectUpdates() {

	// Create packet
	_Buffer Packet;
	Packet.Write<PacketType>(PacketType::WORLD_OBJECTUPDATES);
	Packet.Write<uint8_t>((uint8_t)NetworkID);

	// Write object count
	Packet.Write<NetworkIDType>((NetworkIDType)Objects.size());

	// Iterate over objects
	for(const auto &Object : Objects) {
		Object->SerializeUpdate(Packet);
	}

	// Send packet to players in map
	BroadcastPacket(Packet, _Network::UNSEQUENCED);
}
Exemple #30
0
void Group::SetTargetIcon(uint8 id, ObjectGuid targetGuid)
{
    if (id >= TARGET_ICON_COUNT)
        return;

    // clean other icons
    if (targetGuid)
        for (int i = 0; i < TARGET_ICON_COUNT; ++i)
            if (m_targetIcons[i] == targetGuid)
                SetTargetIcon(i, ObjectGuid());

    m_targetIcons[id] = targetGuid;

    WorldPacket data(MSG_RAID_TARGET_UPDATE, (1 + 1 + 8));
    data << uint8(0);                                       // set targets
    data << uint8(id);
    data << targetGuid;
    BroadcastPacket(&data, true);
}