static void TestWStream(skiatest::Reporter* reporter) { SkDynamicMemoryWStream ds; const char s[] = "abcdefghijklmnopqrstuvwxyz"; int i; for (i = 0; i < 100; i++) { REPORTER_ASSERT(reporter, ds.write(s, 26)); } REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26); char* dst = new char[100 * 26 + 1]; dst[100*26] = '*'; ds.copyTo(dst); REPORTER_ASSERT(reporter, dst[100*26] == '*'); for (i = 0; i < 100; i++) { REPORTER_ASSERT(reporter, memcmp(&dst[i * 26], s, 26) == 0); } { SkAutoTDelete<SkStreamAsset> stream(ds.detachAsStream()); REPORTER_ASSERT(reporter, 100 * 26 == stream->getLength()); REPORTER_ASSERT(reporter, ds.getOffset() == 0); test_loop_stream(reporter, stream.get(), s, 26, 100); SkAutoTDelete<SkStreamAsset> stream2(stream->duplicate()); test_loop_stream(reporter, stream2.get(), s, 26, 100); SkAutoTDelete<SkStreamAsset> stream3(stream->fork()); REPORTER_ASSERT(reporter, stream3->isAtEnd()); char tmp; size_t bytes = stream->read(&tmp, 1); REPORTER_ASSERT(reporter, 0 == bytes); stream3->rewind(); test_loop_stream(reporter, stream3.get(), s, 26, 100); } for (i = 0; i < 100; i++) { REPORTER_ASSERT(reporter, ds.write(s, 26)); } REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26); { sk_sp<SkData> data(ds.copyToData()); REPORTER_ASSERT(reporter, 100 * 26 == data->size()); REPORTER_ASSERT(reporter, memcmp(dst, data->data(), data->size()) == 0); } { // Test that this works after a copyToData. SkAutoTDelete<SkStreamAsset> stream(ds.detachAsStream()); REPORTER_ASSERT(reporter, ds.getOffset() == 0); test_loop_stream(reporter, stream.get(), s, 26, 100); SkAutoTDelete<SkStreamAsset> stream2(stream->duplicate()); test_loop_stream(reporter, stream2.get(), s, 26, 100); } delete[] dst; SkString tmpDir = skiatest::GetTmpDir(); if (!tmpDir.isEmpty()) { test_filestreams(reporter, tmpDir.c_str()); } }
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/ void WorldSession::HandleRequestPartyMemberStatsOpcode( WorldPacket &recv_data ) { DEBUG_LOG("WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS"); uint64 Guid; recv_data >> Guid; Player *player = sObjectMgr.GetPlayer(Guid); if(!player) { WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2); data.appendPackGUID(Guid); data << uint32(GROUP_UPDATE_FLAG_STATUS); data << uint8(MEMBER_STATUS_OFFLINE); SendPacket(&data); return; } Pet *pet = player->GetPet(); WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8); data << player->GetPackGUID(); uint32 mask1 = 0x00040BFF; // common mask, real flags used 0x000040BFF if(pet) mask1 = 0x7FFFFFFF; // for hunters and other classes with pets Powers powerType = player->getPowerType(); data << uint32(mask1); // group update mask data << uint8(MEMBER_STATUS_ONLINE); // member's online status data << uint16(player->GetHealth()); // GROUP_UPDATE_FLAG_CUR_HP data << uint16(player->GetMaxHealth()); // GROUP_UPDATE_FLAG_MAX_HP data << uint8(powerType); // GROUP_UPDATE_FLAG_POWER_TYPE data << uint16(player->GetPower(powerType)); // GROUP_UPDATE_FLAG_CUR_POWER data << uint16(player->GetMaxPower(powerType)); // GROUP_UPDATE_FLAG_MAX_POWER data << uint16(player->getLevel()); // GROUP_UPDATE_FLAG_LEVEL data << uint16(player->GetZoneId()); // GROUP_UPDATE_FLAG_ZONE data << uint16(player->GetPositionX()); // GROUP_UPDATE_FLAG_POSITION data << uint16(player->GetPositionY()); // GROUP_UPDATE_FLAG_POSITION uint32 auramask = 0; size_t maskPos = data.wpos(); data << uint32(auramask); // placeholder for(uint8 i = 0; i < MAX_AURAS; ++i) { if(uint32 aura = player->GetUInt32Value(UNIT_FIELD_AURA + i)) { auramask |= (uint32(1) << i); data << uint16(aura); } } data.put<uint32>(maskPos,auramask); // GROUP_UPDATE_FLAG_AURAS if(pet) { Powers petpowertype = pet->getPowerType(); data << uint64(pet->GetGUID()); // GROUP_UPDATE_FLAG_PET_GUID data << pet->GetName(); // GROUP_UPDATE_FLAG_PET_NAME data << uint16(pet->GetDisplayId()); // GROUP_UPDATE_FLAG_PET_MODEL_ID data << uint16(pet->GetHealth()); // GROUP_UPDATE_FLAG_PET_CUR_HP data << uint16(pet->GetMaxHealth()); // GROUP_UPDATE_FLAG_PET_MAX_HP data << uint8(petpowertype); // GROUP_UPDATE_FLAG_PET_POWER_TYPE data << uint16(pet->GetPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_CUR_POWER data << uint16(pet->GetMaxPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_MAX_POWER uint32 petauramask = 0; size_t petMaskPos = data.wpos(); data << uint32(petauramask); // placeholder for(uint8 i = 0; i < MAX_AURAS; ++i) { if(uint32 petaura = pet->GetUInt32Value(UNIT_FIELD_AURA + i)) { petauramask |= (uint32(1) << i); data << uint16(petaura); } } data.put<uint32>(petMaskPos,petauramask); // GROUP_UPDATE_FLAG_PET_AURAS } else { data << uint8(0); // GROUP_UPDATE_FLAG_PET_NAME data << uint32(0); // GROUP_UPDATE_FLAG_PET_AURAS } SendPacket(&data); }
ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const u32_le* src_cmdbuf, Process& src_process, HandleTable& src_table) { IPC::Header header{src_cmdbuf[0]}; std::size_t untranslated_size = 1u + header.normal_params_size; std::size_t command_size = untranslated_size + header.translate_params_size; ASSERT(command_size <= IPC::COMMAND_BUFFER_LENGTH); // TODO(yuriks): Return error std::copy_n(src_cmdbuf, untranslated_size, cmd_buf.begin()); std::size_t i = untranslated_size; while (i < command_size) { u32 descriptor = cmd_buf[i] = src_cmdbuf[i]; i += 1; switch (IPC::GetDescriptorType(descriptor)) { case IPC::DescriptorType::CopyHandle: case IPC::DescriptorType::MoveHandle: { u32 num_handles = IPC::HandleNumberFromDesc(descriptor); ASSERT(i + num_handles <= command_size); // TODO(yuriks): Return error for (u32 j = 0; j < num_handles; ++j) { Handle handle = src_cmdbuf[i]; SharedPtr<Object> object = nullptr; if (handle != 0) { object = src_table.GetGeneric(handle); ASSERT(object != nullptr); // TODO(yuriks): Return error if (descriptor == IPC::DescriptorType::MoveHandle) { src_table.Close(handle); } } cmd_buf[i++] = AddOutgoingHandle(std::move(object)); } break; } case IPC::DescriptorType::CallingPid: { cmd_buf[i++] = src_process.process_id; break; } case IPC::DescriptorType::StaticBuffer: { VAddr source_address = src_cmdbuf[i]; IPC::StaticBufferDescInfo buffer_info{descriptor}; // Copy the input buffer into our own vector and store it. std::vector<u8> data(buffer_info.size); Memory::ReadBlock(src_process, source_address, data.data(), data.size()); AddStaticBuffer(buffer_info.buffer_id, std::move(data)); cmd_buf[i++] = source_address; break; } case IPC::DescriptorType::MappedBuffer: { u32 next_id = static_cast<u32>(request_mapped_buffers.size()); request_mapped_buffers.emplace_back(src_process, descriptor, src_cmdbuf[i], next_id); cmd_buf[i++] = next_id; break; } default: UNIMPLEMENTED_MSG("Unsupported handle translation: {:#010X}", descriptor); } } return RESULT_SUCCESS; }
////////////////////////////////////////////////////////////// /// This function handles CMSG_GAMEOBJECT_QUERY: ////////////////////////////////////////////////////////////// void WorldSession::HandleGameObjectQueryOpcode(WorldPacket & recv_data) { CHECK_INWORLD_RETURN CHECK_PACKET_SIZE(recv_data, 10); WorldPacket data(SMSG_GAMEOBJECT_QUERY_RESPONSE, 900); uint32 entryID; uint64 guid; GameObjectInfo* goinfo; recv_data >> entryID; recv_data >> guid; LOG_DETAIL("WORLD: CMSG_GAMEOBJECT_QUERY '%u'", entryID); goinfo = GameObjectNameStorage.LookupEntry(entryID); if(goinfo == NULL) return; LocalizedGameObjectName* lgn = (language > 0) ? sLocalizationMgr.GetLocalizedGameObjectName(entryID, language) : NULL; data << entryID; // unique identifier of the GO template data << goinfo->Type; // type of the gameobject data << goinfo->DisplayID; // displayid/modelid of the gameobject // Name of the gameobject if(lgn) data << lgn->Name; else data << goinfo->Name; data << uint8(0); // name2, always seems to be empty data << uint8(0); // name3, always seems to be empty data << uint8(0); // name4, always seems to be empty data << goinfo->Category; // Category string of the GO, like "attack", "pvp", "point", etc data << goinfo->Castbartext; // text displayed when using the go, like "collecting", "summoning" etc data << goinfo->Unkstr; data << goinfo->SpellFocus; // spellfocus id, ex.: spell casted when interacting with the GO data << goinfo->sound1; data << goinfo->sound2; data << goinfo->sound3; data << goinfo->sound4; data << goinfo->sound5; data << goinfo->sound6; data << goinfo->sound7; data << goinfo->sound8; data << goinfo->sound9; data << goinfo->Unknown1; data << goinfo->Unknown2; data << goinfo->Unknown3; data << goinfo->Unknown4; data << goinfo->Unknown5; data << goinfo->Unknown6; data << goinfo->Unknown7; data << goinfo->Unknown8; data << goinfo->Unknown9; data << goinfo->Unknown10; data << goinfo->Unknown11; data << goinfo->Unknown12; data << goinfo->Unknown13; data << goinfo->Unknown14; data << uint32(0); data << uint32(0); data << uint32(0); data << uint32(0); data << uint32(0); data << uint32(0); data << uint32(0); data << uint32(0); // Questitems that the go can contain for(uint32 i = 0; i < 6; ++i) { data << uint32(goinfo->QuestItems[i]); } data < uint32(0); // Go expansion field SendPacket(&data); }
int main(int argc, char const *argv[]) { if (argc != 4) { std::cerr << "Usage: ./thlsh_test data_file lsh_file benchmark_file" << std::endl; return -1; } std::cout << "Example of using Thresholding LSH" << std::endl << std::endl; typedef float DATATYPE; std::cout << "LOADING DATA ..." << std::endl; lshbox::timer timer; lshbox::Matrix<DATATYPE> data(argv[1]); std::cout << "LOAD TIME: " << timer.elapsed() << "s." << std::endl; std::cout << "CONSTRUCTING INDEX ..." << std::endl; timer.restart(); std::string file(argv[2]); bool use_index = false; lshbox::thLsh<DATATYPE> mylsh; if (use_index) { mylsh.load(file); } else { lshbox::thLsh<DATATYPE>::Parameter param; param.M = 521; param.L = 5; param.D = data.getDim(); param.N = 12; param.Max = std::numeric_limits<float>::max(); param.Min = - std::numeric_limits<float>::max(); for (unsigned i = 0; i != data.getSize(); ++i) { for (unsigned j = 0; j != data.getDim(); ++j) { if (data[i][j] > param.Max) { param.Max = data[i][j]; } if (data[i][j] < param.Min) { param.Min = data[i][j]; } } } mylsh.reset(param); lshbox::progress_display pd(data.getSize()); for (unsigned i = 0; i != data.getSize(); ++i) { mylsh.insert(i, data[i]); ++pd; } } mylsh.save(file); std::cout << "CONSTRUCTING TIME: " << timer.elapsed() << "s." << std::endl; std::cout << "LOADING BENCHMARK ..." << std::endl; timer.restart(); lshbox::Matrix<DATATYPE>::Accessor accessor(data); lshbox::Metric<DATATYPE> metric(data.getDim(), L1_DIST); lshbox::Benchmark bench; std::string benchmark(argv[3]); bench.load(benchmark); unsigned K = bench.getK(); lshbox::Scanner<lshbox::Matrix<DATATYPE>::Accessor> scanner( accessor, metric, K ); std::cout << "LOADING TIME: " << timer.elapsed() << "s." << std::endl; std::cout << "RUNING QUERY ..." << std::endl; timer.restart(); lshbox::Stat cost, recall, precision; lshbox::progress_display pd(bench.getQ()); for (unsigned i = 0; i != bench.getQ(); ++i) { scanner.reset(data[bench.getQuery(i)]); mylsh.query(data[bench.getQuery(i)], scanner); scanner.topk().genTopk(); recall << bench.getAnswer(i).recall(scanner.topk()); recall << bench.getAnswer(i).precision(scanner.topk()); cost << float(scanner.cnt()) / float(data.getSize()); ++pd; } std::cout << "MEAN QUERY TIME: " << timer.elapsed() / bench.getQ() << "s." << std::endl; std::cout << "RECALL : " << recall.getAvg() << " +/- " << recall.getStd() << std::endl; std::cout << "PRECISION: " << recall.getAvg() << " +/- " << recall.getStd() << std::endl; std::cout << "COST : " << cost.getAvg() << " +/- " << cost.getStd() << std::endl; // scanner.reset(data[0]); // mylsh.query(data[0], scanner); // scanner.topk().genTopk(); // std::vector<std::pair<float, unsigned> > res = scanner.topk().getTopk(); // for (std::vector<std::pair<float, unsigned> >::iterator it = res.begin(); it != res.end(); ++it) // { // std::cout << it->second << ": " << it->first << std::endl; // } // std::cout << "DISTANCE COMPARISON TIMES: " << scanner.cnt() << std::endl; }
QVariant DailymotionAccountModel::data(int row, const QByteArray &role) const { return data(index(row, 0), m_roles.key(role)); }
// this is the function to call when we want to load an image tImageTGA * tgaLoad(const char *pszFilename) { int mode,total; tImageTGA *info = NULL; CCFileData data(pszFilename, "rb"); unsigned long nSize = data.getSize(); unsigned char* pBuffer = data.getBuffer(); do { CC_BREAK_IF(!pBuffer); info = (tImageTGA *)malloc(sizeof(tImageTGA)); // get the file header info if (!tgaLoadHeader(pBuffer, nSize, info)) { info->status = TGA_ERROR_MEMORY; break; } // check if the image is color indexed if (info->type == 1) { info->status = TGA_ERROR_INDEXED_COLOR; break; } // check for other types (compressed images) if ((info->type != 2) && (info->type !=3) && (info->type !=10)) { info->status = TGA_ERROR_COMPRESSED_FILE; break; } // mode equals the number of image components mode = info->pixelDepth / 8; // total is the number of unsigned chars to read total = info->height * info->width * mode; // allocate memory for image pixels info->imageData = (unsigned char *)malloc(sizeof(unsigned char) * total); // check to make sure we have the memory required if (info->imageData == NULL) { info->status = TGA_ERROR_MEMORY; break; } bool bLoadImage = false; // finally load the image pixels if (info->type == 10) { bLoadImage = tgaLoadRLEImageData(pBuffer, nSize, info); } else { bLoadImage = tgaLoadImageData(pBuffer, nSize, info); } // check for errors when reading the pixels if (!bLoadImage) { info->status = TGA_ERROR_READING_FILE; break; } info->status = TGA_OK; if (info->flipped) { tgaFlipImage(info); if (info->flipped) { info->status = TGA_ERROR_MEMORY; } } } while (0); return info; }
// decode a given message BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender ) { llassert( mReceiveSize >= 0 ); llassert( mCurrentRMessageTemplate); llassert( !mCurrentRMessageData ); delete mCurrentRMessageData; // just to make sure // The offset tells us how may bytes to skip after the end of the // message name. U8 offset = buffer[PHL_OFFSET]; S32 decode_pos = LL_PACKET_ID_SIZE + (S32)(mCurrentRMessageTemplate->mFrequency) + offset; // create base working data set mCurrentRMessageData = new LLMsgData(mCurrentRMessageTemplate->mName); // loop through the template building the data structure as we go LLMessageTemplate::message_block_map_t::const_iterator iter; for(iter = mCurrentRMessageTemplate->mMemberBlocks.begin(); iter != mCurrentRMessageTemplate->mMemberBlocks.end(); ++iter) { LLMessageBlock* mbci = *iter; U8 repeat_number; S32 i; // how many of this block? if (mbci->mType == MBT_SINGLE) { // just one repeat_number = 1; } else if (mbci->mType == MBT_MULTIPLE) { // a known number repeat_number = mbci->mNumber; } else if (mbci->mType == MBT_VARIABLE) { // need to read the number from the message // repeat number is a single byte if (decode_pos >= mReceiveSize) { // commented out - hetgrid says that missing variable blocks // at end of message are legal // logRanOffEndOfPacket(sender, decode_pos, 1); // default to 0 repeats repeat_number = 0; } else { repeat_number = buffer[decode_pos]; decode_pos++; } } else { llerrs << "Unknown block type" << llendl; return FALSE; } LLMsgBlkData* cur_data_block = NULL; // now loop through the block for (i = 0; i < repeat_number; i++) { if (i) { // build new name to prevent collisions // TODO: This should really change to a vector cur_data_block = new LLMsgBlkData(mbci->mName, repeat_number); cur_data_block->mName = mbci->mName + i; } else { cur_data_block = new LLMsgBlkData(mbci->mName, repeat_number); } // add the block to the message mCurrentRMessageData->addBlock(cur_data_block); // now read the variables for (LLMessageBlock::message_variable_map_t::const_iterator iter = mbci->mMemberVariables.begin(); iter != mbci->mMemberVariables.end(); iter++) { const LLMessageVariable& mvci = **iter; // ok, build out the variables // add variable block cur_data_block->addVariable(mvci.getName(), mvci.getType()); // what type of variable? if (mvci.getType() == MVT_VARIABLE) { // variable, get the number of bytes to read from the template S32 data_size = mvci.getSize(); U8 tsizeb = 0; U16 tsizeh = 0; U32 tsize = 0; if ((decode_pos + data_size) > mReceiveSize) { logRanOffEndOfPacket(sender, decode_pos, data_size); // default to 0 length variable blocks tsize = 0; } else { switch(data_size) { case 1: htonmemcpy(&tsizeb, &buffer[decode_pos], MVT_U8, 1); tsize = tsizeb; break; case 2: htonmemcpy(&tsizeh, &buffer[decode_pos], MVT_U16, 2); tsize = tsizeh; break; case 4: htonmemcpy(&tsize, &buffer[decode_pos], MVT_U32, 4); break; default: llerrs << "Attempting to read variable field with unknown size of " << data_size << llendl; break; } } decode_pos += data_size; cur_data_block->addData(mvci.getName(), &buffer[decode_pos], tsize, mvci.getType()); decode_pos += tsize; } else { // fixed! // so, copy data pointer and set data size to fixed size if ((decode_pos + mvci.getSize()) > mReceiveSize) { logRanOffEndOfPacket(sender, decode_pos, mvci.getSize()); // default to 0s. U32 size = mvci.getSize(); std::vector<U8> data(size); memset(&(data[0]), 0, size); cur_data_block->addData(mvci.getName(), &(data[0]), size, mvci.getType()); } else { cur_data_block->addData(mvci.getName(), &buffer[decode_pos], mvci.getSize(), mvci.getType()); } decode_pos += mvci.getSize(); } } } } if (mCurrentRMessageData->mMemberBlocks.empty() && !mCurrentRMessageTemplate->mMemberBlocks.empty()) { lldebugs << "Empty message '" << mCurrentRMessageTemplate->mName << "' (no blocks)" << llendl; return FALSE; } { static LLTimer decode_timer; if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback()) { decode_timer.reset(); } { LLFastTimer t(LLFastTimer::FTM_PROCESS_MESSAGES); if( !mCurrentRMessageTemplate->callHandlerFunc(gMessageSystem) ) { llwarns << "Message from " << sender << " with no handler function received: " << mCurrentRMessageTemplate->mName << llendl; } } if(LLMessageReader::getTimeDecodes() || gMessageSystem->getTimingCallback()) { F32 decode_time = decode_timer.getElapsedTimeF32(); if (gMessageSystem->getTimingCallback()) { (gMessageSystem->getTimingCallback())(mCurrentRMessageTemplate->mName, decode_time, gMessageSystem->getTimingCallbackData()); } if (LLMessageReader::getTimeDecodes()) { mCurrentRMessageTemplate->mDecodeTimeThisFrame += decode_time; mCurrentRMessageTemplate->mTotalDecoded++; mCurrentRMessageTemplate->mTotalDecodeTime += decode_time; if( mCurrentRMessageTemplate->mMaxDecodeTimePerMsg < decode_time ) { mCurrentRMessageTemplate->mMaxDecodeTimePerMsg = decode_time; } if(decode_time > LLMessageReader::getTimeDecodesSpamThreshold()) { lldebugs << "--------- Message " << mCurrentRMessageTemplate->mName << " decode took " << decode_time << " seconds. (" << mCurrentRMessageTemplate->mMaxDecodeTimePerMsg << " max, " << (mCurrentRMessageTemplate->mTotalDecodeTime / mCurrentRMessageTemplate->mTotalDecoded) << " avg)" << llendl; } } } } return TRUE; }
/// %Log the player out void WorldSession::LogoutPlayer(bool Save) { // finish pending transfers before starting the logout while (_player && _player->IsBeingTeleportedFar()) HandleMoveWorldportAckOpcode(); m_playerLogout = true; m_playerSave = Save; if (_player) { sLog.outChar("Account: %d (IP: %s) Logout Character:[%s] (guid: %u)", GetAccountId(), GetRemoteAddress().c_str(), _player->GetName() , _player->GetGUIDLow()); if (ObjectGuid lootGuid = GetPlayer()->GetLootGuid()) DoLootRelease(lootGuid); ///- If the player just died before logging out, make him appear as a ghost // FIXME: logout must be delayed in case lost connection with client in time of combat if (_player->GetDeathTimer()) { _player->getHostileRefManager().deleteReferences(); _player->BuildPlayerRepop(); _player->RepopAtGraveyard(); } else if (!_player->getAttackers().empty()) { _player->CombatStop(); _player->getHostileRefManager().setOnlineOfflineState(false); _player->RemoveAllAurasOnDeath(); // build set of player who attack _player or who have pet attacking of _player std::set<Player*> aset; for (Unit::AttackerSet::const_iterator itr = _player->getAttackers().begin(); itr != _player->getAttackers().end(); ++itr) { Unit* owner = (*itr)->GetOwner(); // including player controlled case if (owner) { if (owner->GetTypeId() == TYPEID_PLAYER) aset.insert((Player*)owner); } else if ((*itr)->GetTypeId() == TYPEID_PLAYER) aset.insert((Player*)(*itr)); } _player->SetPvPDeath(!aset.empty()); _player->KillPlayer(); _player->BuildPlayerRepop(); _player->RepopAtGraveyard(); // give honor to all attackers from set like group case for (std::set<Player*>::const_iterator itr = aset.begin(); itr != aset.end(); ++itr) (*itr)->RewardHonor(_player, aset.size()); // give bg rewards and update counters like kill by first from attackers // this can't be called for all attackers. if (!aset.empty()) if (BattleGround* bg = _player->GetBattleGround()) bg->HandleKillPlayer(_player, *aset.begin()); } else if (_player->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION)) { // this will kill character by SPELL_AURA_SPIRIT_OF_REDEMPTION _player->RemoveSpellsCausingAura(SPELL_AURA_MOD_SHAPESHIFT); //_player->SetDeathPvP(*); set at SPELL_AURA_SPIRIT_OF_REDEMPTION apply time _player->KillPlayer(); _player->BuildPlayerRepop(); _player->RepopAtGraveyard(); } // drop a flag if player is carrying it if (BattleGround* bg = _player->GetBattleGround()) bg->EventPlayerLoggedOut(_player); ///- Teleport to home if the player is in an invalid instance if (!_player->m_InstanceValid && !_player->isGameMaster()) { _player->TeleportToHomebind(); // this is a bad place to call for far teleport because we need player to be in world for successful logout // maybe we should implement delayed far teleport logout? } // FG: finish pending transfers after starting the logout // this should fix players beeing able to logout and login back with full hp at death position while (_player->IsBeingTeleportedFar()) HandleMoveWorldportAckOpcode(); for (int i = 0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; ++i) { if (BattleGroundQueueTypeId bgQueueTypeId = _player->GetBattleGroundQueueTypeId(i)) { _player->RemoveBattleGroundQueueId(bgQueueTypeId); sBattleGroundMgr.m_BattleGroundQueues[ bgQueueTypeId ].RemovePlayer(_player->GetObjectGuid(), true); } } ///- Reset the online field in the account table // no point resetting online in character table here as Player::SaveToDB() will set it to 1 since player has not been removed from world at this stage // No SQL injection as AccountID is uint32 static SqlStatementID id; SqlStatement stmt = LoginDatabase.CreateStatement(id, "UPDATE account SET active_realm_id = ? WHERE id = ?"); stmt.PExecute(uint32(0), GetAccountId()); ///- If the player is in a guild, update the guild roster and broadcast a logout message to other guild members if (Guild* guild = sGuildMgr.GetGuildById(_player->GetGuildId())) { if (MemberSlot* slot = guild->GetMemberSlot(_player->GetObjectGuid())) { slot->SetMemberStats(_player); slot->UpdateLogoutTime(); } guild->BroadcastEvent(GE_SIGNED_OFF, _player->GetObjectGuid(), _player->GetName()); } ///- Remove pet _player->RemovePet(PET_SAVE_AS_CURRENT); ///- empty buyback items and save the player in the database // some save parts only correctly work in case player present in map/player_lists (pets, etc) if (Save) _player->SaveToDB(); ///- Leave all channels before player delete... _player->CleanupChannels(); ///- If the player is in a group (or invited), remove him. If the group if then only 1 person, disband the group. _player->UninviteFromGroup(); // remove player from the group if he is: // a) in group; b) not in raid group; c) logging out normally (not being kicked or disconnected) if (_player->GetGroup() && !_player->GetGroup()->isRaidGroup() && m_Socket) _player->RemoveFromGroup(); ///- Send update to group if (_player->GetGroup()) _player->GetGroup()->SendUpdate(); ///- Broadcast a logout message to the player's friends sSocialMgr.SendFriendStatus(_player, FRIEND_OFFLINE, _player->GetObjectGuid(), true); sSocialMgr.RemovePlayerSocial(_player->GetGUIDLow()); ///- Remove the player from the world // the player may not be in the world when logging out // e.g if he got disconnected during a transfer to another map // calls to GetMap in this case may cause crashes if (_player->IsInWorld()) { Map* _map = _player->GetMap(); _map->Remove(_player, true); } else { _player->CleanupsBeforeDelete(); Map::DeleteFromWorld(_player); } SetPlayer(NULL); // deleted in Remove/DeleteFromWorld call ///- Send the 'logout complete' packet to the client WorldPacket data(SMSG_LOGOUT_COMPLETE, 0); SendPacket(&data); ///- Since each account can only have one online character at any given time, ensure all characters for active account are marked as offline // No SQL injection as AccountId is uint32 static SqlStatementID updChars; stmt = CharacterDatabase.CreateStatement(updChars, "UPDATE characters SET online = 0 WHERE account = ?"); stmt.PExecute(GetAccountId()); DEBUG_LOG("SESSION: Sent SMSG_LOGOUT_COMPLETE Message"); } m_playerLogout = false; m_playerSave = false; m_playerRecentlyLogout = true; LogoutRequest(0); }
bool CCoinControlWidgetItem::operator<(const QTreeWidgetItem &other) const { int column = treeWidget()->sortColumn(); if (column == CoinControlDialog::COLUMN_AMOUNT || column == CoinControlDialog::COLUMN_DATE || column == CoinControlDialog::COLUMN_CONFIRMATIONS || column == CoinControlDialog::COLUMN_PRIVATESEND_ROUNDS) return data(column, Qt::UserRole).toLongLong() < other.data(column, Qt::UserRole).toLongLong(); return QTreeWidgetItem::operator<(other); }
void WorldSession::SendUpdateTrade() { Item *item = NULL; if (!_player || !_player->pTrader) return; // reset trade status if (_player->acceptTrade) { _player->acceptTrade = false; SendTradeStatus(TRADE_STATUS_BACK_TO_TRADE); } if (_player->pTrader->acceptTrade) { _player->pTrader->acceptTrade = false; _player->pTrader->GetSession()->SendTradeStatus(TRADE_STATUS_BACK_TO_TRADE); } WorldPacket data(SMSG_TRADE_STATUS_EXTENDED, (100)); // guess size data << (uint8) 1; // can be different (only seen 0 and 1) data << (uint32) 0; // added in 2.4.0, this value must be equal to value from TRADE_STATUS_OPEN_WINDOW status packet (different value for different players to block multiple trades?) data << (uint32) TRADE_SLOT_COUNT; // trade slots count/number?, = next field in most cases data << (uint32) TRADE_SLOT_COUNT; // trade slots count/number?, = prev field in most cases data << (uint32) _player->pTrader->tradeGold; // trader gold data << (uint32) 0; // spell casted on lowest slot item for (uint8 i = 0; i < TRADE_SLOT_COUNT; i++) { item = (_player->pTrader->tradeItems[i] != NULL_SLOT ? _player->pTrader->GetItemByPos(_player->pTrader->tradeItems[i]) : NULL); data << (uint8) i; // trade slot number, if not specified, then end of packet if (item) { data << (uint32) item->GetProto()->ItemId; // entry // display id data << (uint32) item->GetProto()->DisplayInfoID; // stack count data << (uint32) item->GetUInt32Value(ITEM_FIELD_STACK_COUNT); data << (uint32) 0; // probably gift=1, created_by=0? // gift creator data << (uint64) item->GetUInt64Value(ITEM_FIELD_GIFTCREATOR); data << (uint32) item->GetEnchantmentId(PERM_ENCHANTMENT_SLOT); for (uint8 j = 0; j < 3; ++j) data << (uint32) 0; // enchantment id (permanent/gems?) // creator data << (uint64) item->GetUInt64Value(ITEM_FIELD_CREATOR); data << (uint32) item->GetSpellCharges(); // charges data << (uint32) item->GetItemSuffixFactor(); // SuffixFactor // random properties id data << (uint32) item->GetItemRandomPropertyId(); data << (uint32) item->GetProto()->LockID; // lock id // max durability data << (uint32) item->GetUInt32Value(ITEM_FIELD_MAXDURABILITY); // durability data << (uint32) item->GetUInt32Value(ITEM_FIELD_DURABILITY); } else { for (uint8 j = 0; j < 18; j++) data << uint32(0); } } SendPacket(&data); }
void OnReachWP(uint32 iWaypointId, bool bForwards) { switch(iWaypointId) { case 1: { _unit->GetAIInterface()->setMoveType(MOVEMENTTYPE_WANTEDWP); _unit->GetAIInterface()->setWaypointToMove(2); Fly(); }break; case 2: { _unit->GetAIInterface()->setMoveType(MOVEMENTTYPE_WANTEDWP); _unit->GetAIInterface()->setWaypointToMove(3); }break; case 3: { _unit->GetAIInterface()->m_canMove = false; _unit->GetAIInterface()->SetAllowedToEnterCombat(true); _unit->GetAIInterface()->setCurrentAgent(AGENT_SPELL); //_unit->m_pacified--; _unit->GetAIInterface()->SetAIState(STATE_SCRIPTIDLE); _unit->GetAIInterface()->setMoveType(MOVEMENTTYPE_DONTMOVEWP); _unit->GetAIInterface()->setWaypointToMove(0); WorldPacket data(SMSG_MOVE_SET_HOVER, 13); data << _unit->GetNewGUID(); data << uint32(0); _unit->SendMessageToSet(&data, false); m_currentWP = 3; }break; case 8: { _unit->GetAIInterface()->SetAllowedToEnterCombat(true); _unit->GetAIInterface()->setCurrentAgent(AGENT_NULL); _unit->GetAIInterface()->SetAIState(STATE_SCRIPTIDLE); _unit->GetAIInterface()->setMoveType(MOVEMENTTYPE_DONTMOVEWP); _unit->GetAIInterface()->setWaypointToMove(0); /*_unit->m_pacified--; if(_unit->m_pacified > 0) _unit->m_pacified--;*/ WorldPacket data(SMSG_MOVE_UNSET_HOVER, 13); data << _unit->GetNewGUID(); data << uint32(0); _unit->SendMessageToSet(&data, false); Land(); }break; default: { _unit->GetAIInterface()->m_canMove = false; _unit->GetAIInterface()->SetAllowedToEnterCombat(true); _unit->GetAIInterface()->SetAIState(STATE_SCRIPTIDLE); _unit->GetAIInterface()->setMoveType(MOVEMENTTYPE_DONTMOVEWP); _unit->GetAIInterface()->setWaypointToMove(0); WorldPacket data(SMSG_MOVE_SET_HOVER, 13); data << _unit->GetNewGUID(); data << uint32(0); _unit->SendMessageToSet(&data, false); //_unit->m_pacified--; }break; }; }
const unsigned char & ImageRGB::at(unsigned int x, unsigned int y, Channel channel) const { auto ptr = data(x, y, channel); return *ptr; }
ImageRGB::const_reference ImageRGB::at(unsigned int x, unsigned int y) const { auto ptrs = data(x, y); return ImageRGB::const_reference(*ptrs.red, *ptrs.green, *ptrs.blue); }
void BitmapTextureImageBuffer::updateContents(const void* data, const IntRect& targetRect, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag) { #if PLATFORM(QT) QImage image(reinterpret_cast<const uchar*>(data), targetRect.width(), targetRect.height(), bytesPerLine, NativeImageQt::defaultFormatForAlphaEnabledImages()); QPainter* painter = m_image->context()->platformContext(); painter->save(); painter->setCompositionMode(QPainter::CompositionMode_Source); painter->drawImage(targetRect, image, IntRect(sourceOffset, targetRect.size())); painter->restore(); #elif PLATFORM(CAIRO) RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create_for_data(static_cast<unsigned char*>(data()), CAIRO_FORMAT_ARGB32, targetRect.width(), targetRect.height(), bytesPerLine)); m_image->context()->platformContext()->drawSurfaceToContext(surface.get(), targetRect, IntRect(sourceOffset, targetRect.size()), m_image->context()); #else UNUSED_PARAM(data); UNUSED_PARAM(targetRect); UNUSED_PARAM(sourceOffset); UNUSED_PARAM(bytesPerLine); #endif }
/// %Log the player out void WorldSession::LogoutPlayer (bool Save) { // finish pending transfers before starting the logout while (_player && _player->IsBeingTeleportedFar()) HandleMoveWorldportAckOpcode(); m_playerLogout = true; m_playerSave = Save; if (_player) { if (uint64 lguid = GetPlayer()->GetLootGUID()) DoLootRelease(lguid); ///- If the player just died before logging out, make him appear as a ghost //FIXME: logout must be delayed in case lost connection with client in time of combat if (_player->GetDeathTimer()) { _player->getHostileRefManager().deleteReferences(); _player->BuildPlayerRepop(); _player->RepopAtGraveyard(); } else if (!_player->getAttackers().empty()) { _player->CombatStop(); _player->getHostileRefManager().setOnlineOfflineState(false); _player->RemoveAllAurasOnDeath(); // build set of player who attack _player or who have pet attacking of _player std::set<Player*> aset; for (Unit::AttackerSet::const_iterator itr = _player->getAttackers().begin(); itr != _player->getAttackers().end(); ++itr) { Unit* owner = (*itr)->GetOwner(); // including player controlled case if (owner) { if (owner->GetTypeId() == TYPEID_PLAYER) aset.insert(owner->ToPlayer()); } else if ((*itr)->GetTypeId() == TYPEID_PLAYER) aset.insert((Player*) (*itr)); } _player->SetPvPDeath(!aset.empty()); _player->KillPlayer(); _player->BuildPlayerRepop(); _player->RepopAtGraveyard(); // give honor to all attackers from set like group case for (std::set<Player*>::const_iterator itr = aset.begin(); itr != aset.end(); ++itr) (*itr)->RewardHonor(_player, aset.size()); // give bg rewards and update counters like kill by first from attackers // this can't be called for all attackers. if (!aset.empty()) if (Battleground *bg = _player->GetBattleground()) bg->HandleKillPlayer(_player, *aset.begin()); } else if (_player->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION)) { // this will kill character by SPELL_AURA_SPIRIT_OF_REDEMPTION _player->RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT); //_player->SetDeathPvP(*); set at SPELL_AURA_SPIRIT_OF_REDEMPTION apply time _player->KillPlayer(); _player->BuildPlayerRepop(); _player->RepopAtGraveyard(); } else if (_player->HasPendingBind()) { _player->RepopAtGraveyard(); _player->SetPendingBind(NULL, 0); } //drop a flag if player is carrying it if (Battleground *bg = _player->GetBattleground()) bg->EventPlayerLoggedOut(_player); ///- Teleport to home if the player is in an invalid instance if (!_player->m_InstanceValid && !_player->isGameMaster()) _player->TeleportTo(_player->m_homebindMapId, _player->m_homebindX, _player->m_homebindY, _player->m_homebindZ, _player->GetOrientation()); sOutdoorPvPMgr->HandlePlayerLeaveZone(_player, _player->GetZoneId()); for (int i = 0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; ++i) { if (BattlegroundQueueTypeId bgQueueTypeId = _player->GetBattlegroundQueueTypeId(i)) { _player->RemoveBattlegroundQueueId(bgQueueTypeId); sBattlegroundMgr->m_BattlegroundQueues[bgQueueTypeId].RemovePlayer(_player->GetGUID(), true); } } // Repop at GraveYard or other player far teleport will prevent saving player because of not present map // Teleport player immediately for correct player save while (_player->IsBeingTeleportedFar()) HandleMoveWorldportAckOpcode(); ///- If the player is in a guild, update the guild roster and broadcast a logout message to other guild members if (Guild* pGuild = sGuildMgr->GetGuildById(_player->GetGuildId())) pGuild->HandleMemberLogout(this); ///- Remove pet _player->RemovePet(NULL, PET_SLOT_ACTUAL_PET_SLOT, true); ///- empty buyback items and save the player in the database // some save parts only correctly work in case player present in map/player_lists (pets, etc) if (Save) { uint32 eslot; for (int j = BUYBACK_SLOT_START; j < BUYBACK_SLOT_END; ++j) { eslot = j - BUYBACK_SLOT_START; _player->SetUInt64Value(PLAYER_FIELD_VENDORBUYBACK_SLOT_1 + (eslot * 2), 0); _player->SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + eslot, 0); _player->SetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP_1 + eslot, 0); } _player->SaveToDB(); } ///- Leave all channels before player delete... _player->CleanupChannels(); ///- If the player is in a group (or invited), remove him. If the group if then only 1 person, disband the group. _player->UninviteFromGroup(); // remove player from the group if he is: // a) in group; b) not in raid group; c) logging out normally (not being kicked or disconnected) if (_player->GetGroup() && !_player->GetGroup()->isRaidGroup() && m_Socket) _player->RemoveFromGroup(); ///- Send update to group and reset stored max enchanting level if (_player->GetGroup()) { _player->GetGroup()->SendUpdate(); _player->GetGroup()->ResetMaxEnchantingLevel(); } ///- Broadcast a logout message to the player's friends sSocialMgr->SendFriendStatus(_player, FRIEND_OFFLINE, _player->GetGUIDLow(), true); sSocialMgr->RemovePlayerSocial(_player->GetGUIDLow()); // Call script hook before deletion sScriptMgr->OnPlayerLogout(GetPlayer()); ///- Remove the player from the world // the player may not be in the world when logging out // e.g if he got disconnected during a transfer to another map // calls to GetMap in this case may cause crashes _player->CleanupsBeforeDelete(); sLog->outChar("Account: %d (IP: %s) Logout Character:[%s] (GUID: %u)", GetAccountId(), GetRemoteAddress().c_str(), _player->GetName(), _player->GetGUIDLow()); Map* _map = _player->GetMap(); _map->Remove(_player, true); SetPlayer (NULL); // deleted in Remove call ///- Send the 'logout complete' packet to the client WorldPacket data(SMSG_LOGOUT_COMPLETE, 0); SendPacket(&data); ///- Since each account can only have one online character at any given time, ensure all characters for active account are marked as offline //No SQL injection as AccountId is uint32 CharacterDatabase.PExecute("UPDATE characters SET online = 0 WHERE account = '%u'", GetAccountId()); sLog->outDebug(LOG_FILTER_NETWORKIO, "SESSION: Sent SMSG_LOGOUT_COMPLETE Message"); } m_playerLogout = false; m_playerSave = false; m_playerRecentlyLogout = true; LogoutRequest(0); }
void GuildFinderMgr::SendMembershipRequestListUpdate(Player& player) { WorldPacket data(SMSG_LF_GUILD_APPLICATIONS_LIST_CHANGED, 0); player.SendDirectMessage(&data); }
void AggrTypeBuilder::addAggregate(AggregateDeclaration *ad) { // mirror the ad->fields array but only fill in contributors const size_t n = ad->fields.dim; LLSmallVector<VarDeclaration*, 16> data(n, NULL); unsigned int errors = global.errors; // first fill in the fields with explicit initializers for (size_t index = 0; index < n; ++index) { VarDeclaration *field = ad->fields[index]; // init is !null for explicit inits if (field->init != NULL && !field->init->isVoidInitializer()) { IF_LOG Logger::println("adding explicit initializer for struct field %s", field->toChars()); size_t f_size = field->type->size(); size_t f_begin = field->offset; size_t f_end = f_begin + f_size; if (f_size == 0) continue; data[index] = field; // make sure there is no overlap for (size_t i = 0; i < index; i++) { if (data[i] != NULL) { VarDeclaration* vd = data[i]; size_t v_begin = vd->offset; size_t v_end = v_begin + vd->type->size(); if (v_begin >= f_end || v_end <= f_begin) continue; ad->error(vd->loc, "has overlapping initialization for %s and %s", field->toChars(), vd->toChars()); } } } } if (errors != global.errors) { // There was an overlapping initialization. // Return if errors are gagged otherwise abort. if (global.gag) return; fatal(); } // fill in default initializers for (size_t index = 0; index < n; ++index) { if (data[index]) continue; VarDeclaration *field = ad->fields[index]; size_t f_size = field->type->size(); size_t f_begin = field->offset; size_t f_end = f_begin + f_size; if (f_size == 0) continue; // make sure it doesn't overlap anything explicit bool overlaps = false; for (size_t i = 0; i < n; i++) { if (data[i]) { size_t v_begin = data[i]->offset; size_t v_end = v_begin + data[i]->type->size(); if (v_begin >= f_end || v_end <= f_begin) continue; overlaps = true; break; } } // if no overlap was found, add the default initializer if (!overlaps) { IF_LOG Logger::println("adding default initializer for struct field %s", field->toChars()); data[index] = field; } } // // ok. now we can build a list of llvm types. and make sure zeros are inserted if necessary. // // first we sort the list by offset std::sort(data.begin(), data.end(), var_offset_sort_cb); // add types to list for (size_t i = 0; i < n; i++) { VarDeclaration* vd = data[i]; if (vd == NULL) continue; assert(vd->offset >= m_offset && "it's a bug... most likely DMD bug 2481"); // get next aligned offset for this type size_t alignedoffset = m_offset; if (!m_packed) { alignedoffset = realignOffset(alignedoffset, vd->type); } // insert explicit padding? if (alignedoffset < vd->offset) { m_fieldIndex += add_zeros(m_defaultTypes, alignedoffset, vd->offset); } // add default type m_defaultTypes.push_back(DtoType(vd->type)); // advance offset to right past this field m_offset = vd->offset + vd->type->size(); // set the field index m_varGEPIndices[vd] = m_fieldIndex; ++m_fieldIndex; } }
void RunWriter(void* arg) { PR_SetCurrentThreadName("Shutdown Statistics Writer"); MOZ_LSAN_INTENTIONALLY_LEAK_OBJECT(arg); // Shutdown will generally complete before we have a chance to // deallocate. This is not a leak. // Setup destinationPath and tmpFilePath nsCString destinationPath(static_cast<char*>(arg)); nsAutoCString tmpFilePath; tmpFilePath.Append(destinationPath); tmpFilePath.AppendLiteral(".tmp"); // Cleanup any file leftover from a previous run Unused << PR_Delete(tmpFilePath.get()); Unused << PR_Delete(destinationPath.get()); while (true) { // // Check whether we have received data from the main thread. // // We perform the check before waiting on `gWriteReady` as we may // have received data while we were busy writing. // // Also note that gWriteData may have been modified several times // since we last checked. That's ok, we are not losing any important // data (since we keep adding data), and we are not leaking memory // (since the main thread deallocates any data that hasn't been // consumed by the writer thread). // UniquePtr<nsCString> data(gWriteData.exchange(nullptr)); if (!data) { // Data is not available yet. // Wait until the main thread provides it. PR_EnterMonitor(gWriteReady); PR_Wait(gWriteReady, PR_INTERVAL_NO_TIMEOUT); PR_ExitMonitor(gWriteReady); continue; } MOZ_LSAN_INTENTIONALLY_LEAK_OBJECT(data.get()); // Shutdown may complete before we have a chance to deallocate. // This is not a leak. // // Write to a temporary file // // In case of any error, we simply give up. Since the data is // hardly critical, we don't want to spend too much effort // salvaging it. // UniquePtr<PRFileDesc, PR_CloseDelete> tmpFileDesc(PR_Open(tmpFilePath.get(), PR_WRONLY | PR_TRUNCATE | PR_CREATE_FILE, 00600)); // Shutdown may complete before we have a chance to close the file. // This is not a leak. MOZ_LSAN_INTENTIONALLY_LEAK_OBJECT(tmpFileDesc.get()); if (tmpFileDesc == nullptr) { break; } if (PR_Write(tmpFileDesc.get(), data->get(), data->Length()) == -1) { break; } tmpFileDesc.reset(); // // Rename on top of destination file. // // This is not sufficient to guarantee that the destination file // will be written correctly, but, again, we don't care enough // about the data to make more efforts. // if (PR_Rename(tmpFilePath.get(), destinationPath.get()) != PR_SUCCESS) { break; } } }
void WorldSession::SendPlayerNotFoundNotice(std::string const& name) { WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, name.size()+1); data << name; SendPacket(&data); }
/** * Handles the packet sent by the client when requesting the current mail list. * It will send a list of all available mails in the players mailbox to the client. */ void WorldSession::HandleGetMailList(WorldPacket& recv_data) { ObjectGuid mailboxGuid; recv_data >> mailboxGuid; if (!CheckMailBox(mailboxGuid)) return; // client can't work with packets > max int16 value const uint32 maxPacketSize = 32767; uint32 mailsCount = 0; // send to client mails amount WorldPacket data(SMSG_MAIL_LIST_RESULT, (200)); // guess size data << uint8(0); // mail's count time_t cur_time = time(nullptr); for (PlayerMails::iterator itr = _player->GetMailBegin(); itr != _player->GetMailEnd(); ++itr) { // packet send mail count as uint8, prevent overflow if (mailsCount >= 254) break; // skip deleted or not delivered (deliver delay not expired) mails if ((*itr)->state == MAIL_STATE_DELETED || cur_time < (*itr)->deliver_time) continue; /*[-ZERO] TODO recheck this size_t next_mail_size = 4+1+8+((*itr)->subject.size()+1)+4*7+1+item_count*(1+4+4+6*3*4+4+4+1+4+4+4); if(data.wpos()+next_mail_size > maxPacketSize) break; */ data << uint32((*itr)->messageID); // Message ID data << uint8((*itr)->messageType); // Message Type switch ((*itr)->messageType) { case MAIL_NORMAL: // sender guid data << ObjectGuid(HIGHGUID_PLAYER, (*itr)->sender); break; case MAIL_CREATURE: case MAIL_GAMEOBJECT: case MAIL_AUCTION: data << (uint32)(*itr)->sender; // creature/gameobject entry, auction id break; case MAIL_ITEM: // item entry (?) sender = "Unknown", NYI break; } data << (*itr)->subject; // Subject string - once 00, when mail type = 3 data << uint32((*itr)->itemTextId); // sure about this data << uint32(0); // unknown data << uint32((*itr)->stationery); // stationery (Stationery.dbc) // 1.12.1 can have only single item Item* item = (*itr)->items.size() > 0 ? _player->GetMItem((*itr)->items[0].item_guid) : nullptr; data << uint32(item ? item->GetEntry() : 0); // entry // permanent enchantment data << uint32(item ? item->GetEnchantmentId((EnchantmentSlot)PERM_ENCHANTMENT_SLOT) : 0); // can be negative data << uint32(item ? item->GetItemRandomPropertyId() : 0); // unk data << uint32(item ? item->GetItemSuffixFactor() : 0); data << uint8(item ? item->GetCount() : 0); // stack count data << uint32(item ? item->GetSpellCharges() : 0); // charges // durability data << uint32(item ? item->GetUInt32Value(ITEM_FIELD_MAXDURABILITY) : 0); // durability data << uint32(item ? item->GetUInt32Value(ITEM_FIELD_DURABILITY) : 0); data << uint32((*itr)->money); // copper data << uint32((*itr)->COD); // Cash on delivery data << uint32((*itr)->checked); // flags data << float(float((*itr)->expire_time - time(nullptr)) / float(DAY));// Time data << uint32((*itr)->mailTemplateId); // mail template (MailTemplate.dbc) mailsCount += 1; } data.put<uint8>(0, mailsCount); // set real send mails to client SendPacket(&data); // recalculate m_nextMailDelivereTime and unReadMails _player->UpdateNextMailTimeAndUnreads(); }
void WorldSession::SendPlayerAmbiguousNotice(std::string const& name) { WorldPacket data(SMSG_CHAT_PLAYER_AMBIGUOUS, name.size()+1); data << name; SendPacket(&data); }
////////////////////////////////////////////////////////////// /// This function handles CMSG_CREATURE_QUERY: ////////////////////////////////////////////////////////////// void WorldSession::HandleCreatureQueryOpcode(WorldPacket & recv_data) { CHECK_INWORLD_RETURN CHECK_PACKET_SIZE(recv_data, 12); WorldPacket data(SMSG_CREATURE_QUERY_RESPONSE, 250); //VLack: thanks Aspire, this was 146 before uint32 entry; uint64 guid; CreatureInfo* ci; recv_data >> entry; recv_data >> guid; if(entry == 300000) { data << (uint32)entry; data << "WayPoint"; data << uint8(0) << uint8(0) << uint8(0); data << "Level is WayPoint ID"; for(uint32 i = 0; i < 8; i++) { data << uint32(0); } data << uint8(0); } else { ci = CreatureNameStorage.LookupEntry(entry); if(ci == NULL) return; LocalizedCreatureName* lcn = (language > 0) ? sLocalizationMgr.GetLocalizedCreatureName(entry, language) : NULL; if(lcn == NULL) { LOG_DETAIL("WORLD: CMSG_CREATURE_QUERY '%s'", ci->Name); data << (uint32)entry; data << ci->Name; // name of the creature data << uint8(0); // name2, always seems to be empty data << uint8(0); // name3, always seems to be empty data << uint8(0); // name4, always seems to be empty data << ci->SubName; // this is the title/guild of the creature } else { LOG_DETAIL("WORLD: CMSG_CREATURE_QUERY '%s' (localized to %s)", ci->Name, lcn->Name); data << (uint32)entry; data << lcn->Name; data << uint8(0); data << uint8(0); data << uint8(0); data << lcn->SubName; } data << ci->info_str; //!!! this is a string in 2.3.0 Example: stormwind guard has : "Direction" data << ci->Flags1; // flags like skinnable data << ci->Type; // humanoid, beast, etc data << ci->Family; // petfamily data << ci->Rank; // normal, elite, etc data << ci->killcredit[0]; // quest kill credit 1 data << ci->killcredit[1]; // quest kill credit 2 data << ci->Male_DisplayID; data << ci->Female_DisplayID; data << ci->Male_DisplayID2; data << ci->Female_DisplayID2; data << ci->unkfloat1; data << ci->unkfloat2; data << ci->Leader; // faction leader // these are the 6 seperate quest items a creature can drop for(uint32 i = 0; i < 6; ++i) { data << uint32(ci->QuestItems[i]); } data << ci->waypointid; } SendPacket(&data); }
void WorldSession::SendWrongFactionNotice() { WorldPacket data(SMSG_CHAT_WRONG_FACTION, 0); SendPacket(&data); }
void WorldSession::HandleGroupInviteOpcode( WorldPacket & recv_data ) { std::string membername; recv_data >> membername; if(_player->InBattleGround()) { SendPartyResult(PARTY_OP_INVITE, membername, ERR_INVITE_RESTRICTED); return; } // attempt add selected player // cheating if(!normalizePlayerName(membername)) { SendPartyResult(PARTY_OP_INVITE, membername, ERR_BAD_PLAYER_NAME_S); return; } Player *player = sObjectMgr.GetPlayer(membername.c_str()); // no player if(!player) { SendPartyResult(PARTY_OP_INVITE, membername, ERR_BAD_PLAYER_NAME_S); return; } // can't group with if(!sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_GROUP) && GetPlayer()->GetTeam() != player->GetTeam()) { SendPartyResult(PARTY_OP_INVITE, membername, ERR_PLAYER_WRONG_FACTION); return; } if(GetPlayer()->GetInstanceId() != 0 && player->GetInstanceId() != 0 && GetPlayer()->GetInstanceId() != player->GetInstanceId() && GetPlayer()->GetMapId() == player->GetMapId()) { SendPartyResult(PARTY_OP_INVITE, membername, ERR_TARGET_NOT_IN_INSTANCE_S); return; } // just ignore us if(player->GetSocial()->HasIgnore(GetPlayer()->GetGUIDLow())) { SendPartyResult(PARTY_OP_INVITE, membername, ERR_IGNORING_YOU_S); return; } // player already in another group or invited if(player->GetGroup() || player->GetGroupInvite() ) { SendPartyResult(PARTY_OP_INVITE, membername, ERR_ALREADY_IN_GROUP_S); return; } Group *group = GetPlayer()->GetGroup(); if(group) { // not have permissions for invite if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID())) { SendPartyResult(PARTY_OP_INVITE, "", ERR_NOT_LEADER); return; } // not have place if(group->IsFull()) { SendPartyResult(PARTY_OP_INVITE, "", ERR_GROUP_FULL); return; } } // ok, but group not exist, start a new group // but don't create and save the group to the DB until // at least one person joins if(!group) { group = new Group; // new group: if can't add then delete if(!group->AddLeaderInvite(GetPlayer())) { delete group; return; } if(!group->AddInvite(player)) { delete group; return; } } else { // already existed group: if can't add then just leave if(!group->AddInvite(player)) { return; } } // ok, we do it WorldPacket data(SMSG_GROUP_INVITE, 10); // guess size data << GetPlayer()->GetName(); player->GetSession()->SendPacket(&data); SendPartyResult(PARTY_OP_INVITE, membername, ERR_PARTY_RESULT_OK); }
void WorldSession::SendChatRestrictedNotice(ChatRestrictionType restriction) { WorldPacket data(SMSG_CHAT_RESTRICTED, 1); data << uint8(restriction); SendPacket(&data); }
//----------------------------------------------------------------------------- // MAIN //----------------------------------------------------------------------------- int main (int argc, char* argv[]) { try { //- yat internal cooking yat::Socket::init(); //- instanciating the Socket (default protocol is yat::Socket::TCP_PROTOCOL) std::cout << "Instanciating the Socket" << std::endl; yat::ClientSocket sock; //- set some socket option std::cout << "Setting sock options" << std::endl; sock.set_option(yat::Socket::SOCK_OPT_KEEP_ALIVE, 1); sock.set_option(yat::Socket::SOCK_OPT_NO_DELAY, 1); sock.set_option(yat::Socket::SOCK_OPT_OTIMEOUT, 1000); sock.set_option(yat::Socket::SOCK_OPT_ITIMEOUT, 1000); int ka = sock.get_option(yat::Socket::SOCK_OPT_KEEP_ALIVE); if (! ka) { std::cout << "unexpected Socket::SOCK_OPT_KEEP_ALIVE opt value" << std::endl; return -1; } int nd = sock.get_option(yat::Socket::SOCK_OPT_NO_DELAY); if (! nd) { std::cout << "unexpected Socket::SOCK_OPT_NO_DELAY opt value" << std::endl; return -1; } int otmo = sock.get_option(yat::Socket::SOCK_OPT_OTIMEOUT); if (otmo != 1000) { std::cout << "unexpected Socket::SOCK_OPT_OTIMEOUT opt value" << std::endl; return -1; } int itmo = sock.get_option(yat::Socket::SOCK_OPT_ITIMEOUT); if (itmo != 1000) { std::cout << "unexpected Socket::SOCK_OPT_ITIMEOUT opt value" << std::endl; return -1; } //- network address std::cout << "Instanciating network address" << std::endl; yat::Address addr("192.168.9.100", 5000); //- connect to addr std::cout << "Connecting to peer..." << std::endl; sock.connect(addr); do { //- read some data //- std::cout << "Sending command to peer" << std::endl; sock.send(UPDATE_DR_CMD); //- retrieve data from peer //- std::cout << "Retrieving data from peer" << std::endl; yat::Socket::Data data(253); size_t nb = sock.receive(data); std::cout << "Got " << nb << " bytes from peer" << std::endl; //- extract data into a QRBlock yat::BitsStream bs(reinterpret_cast<unsigned char *>(data.base()), data.size(), yat::Endianness::BO_LITTLE_ENDIAN); QRBlock qr_block; bs >> qr_block; qr_block.dump(); } while (0); //- disconnect from peer std::cout << "Disconnecting from peer..." << std::endl; sock.disconnect(); //- yat internal cooking yat::Socket::terminate(); } catch (const yat::SocketException & se) { std::cout << "*** yat::SocketException caught ***" << std::endl; for (size_t err = 0; err < se.errors.size(); err++) { std::cout << "Err-" << err << "::reason..." << se.errors[err].reason << std::endl; std::cout << "Err-" << err << "::desc....." << se.errors[err].desc << std::endl; std::cout << "Err-" << err << "::origin..." << se.errors[err].origin << std::endl; std::cout << "Err-" << err << "::code....." << se.errors[err].code << std::endl; } } catch (...) { std::cout << "Unknown exception caught" << std::endl; } return 0; }
/** * This function will board a passenger onto a vehicle * * @param passenger MUST be provided. This Unit will be boarded onto the vehicles (if it checks out) * @param seat Seat to which the passenger will be boarded (if can, elsewise an alternative will be selected if possible) */ void VehicleInfo::Board(Unit* passenger, uint8 seat) { MANGOS_ASSERT(passenger); DEBUG_LOG("VehicleInfo(of %s)::Board: Try to board passenger %s to seat %u", m_owner->GetGuidStr().c_str(), passenger->GetGuidStr().c_str(), seat); // This check is also called in Spell::CheckCast() if (!CanBoard(passenger)) return; // Use the planned seat only if the seat is valid, possible to choose and empty if (!IsSeatAvailableFor(passenger, seat)) if (!GetUsableSeatFor(passenger, seat)) return; VehicleSeatEntry const* seatEntry = GetSeatEntry(seat); MANGOS_ASSERT(seatEntry); // ToDo: Unboard passenger from a MOTransport when they are properly implemented /*if (TransportInfo* transportInfo = passenger->GetTransportInfo()) { WorldObject* transporter = transportInfo->GetTransport(); // Must be a MO transporter MANGOS_ASSERT(transporter->GetObjectGuid().IsMOTransport()); ((Transport*)transporter)->UnBoardPassenger(passenger); }*/ DEBUG_LOG("VehicleInfo::Board: Board passenger: %s to seat %u", passenger->GetGuidStr().c_str(), seat); // Calculate passengers local position float lx, ly, lz, lo; CalculateBoardingPositionOf(passenger->GetPositionX(), passenger->GetPositionY(), passenger->GetPositionZ(), passenger->GetOrientation(), lx, ly, lz, lo); BoardPassenger(passenger, lx, ly, lz, lo, seat); // Use TransportBase to store the passenger // Set data for createobject packets passenger->m_movementInfo.AddMovementFlag(MOVEFLAG_ONTRANSPORT); passenger->m_movementInfo.SetTransportData(m_owner->GetObjectGuid(), lx, ly, lz, lo, 0, seat); if (passenger->GetTypeId() == TYPEID_PLAYER) { Player* pPlayer = (Player*)passenger; pPlayer->RemovePet(PET_SAVE_AS_CURRENT); WorldPacket data(SMSG_ON_CANCEL_EXPECTED_RIDE_VEHICLE_AURA); pPlayer->GetSession()->SendPacket(data); data.Initialize(SMSG_BREAK_TARGET, m_owner->GetPackGUID().size()); data << m_owner->GetPackGUID(); pPlayer->GetSession()->SendPacket(data); pPlayer->SetRoot(true); } else if (passenger->GetTypeId() == TYPEID_UNIT) { if (!passenger->IsRooted()) ((Creature*)passenger)->SetRoot(true); } Movement::MoveSplineInit init(*passenger); init.MoveTo(0.0f, 0.0f, 0.0f); // ToDo: Set correct local coords init.SetFacing(0.0f); // local orientation ? ToDo: Set proper orientation! init.SetBoardVehicle(); init.Launch(); // Apply passenger modifications ApplySeatMods(passenger, seatEntry->m_flags); }
void WorldSession::HandleGroupInviteOpcode( WorldPacket & recv_data ) { std::string membername; recv_data >> membername; // attempt add selected player // cheating if(!normalizePlayerName(membername)) { SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_CANT_FIND_TARGET); return; } Player *player = objmgr.GetPlayer(membername.c_str()); // no player if(!player) { SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_CANT_FIND_TARGET); return; } // can't group with if(!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP) && GetPlayer()->GetTeam() != player->GetTeam()) { SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_TARGET_UNFRIENDLY); return; } if(GetPlayer()->GetInstanceId() != 0 && player->GetInstanceId() != 0 && GetPlayer()->GetInstanceId() != player->GetInstanceId() && GetPlayer()->GetMapId() == player->GetMapId()) { SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_NOT_IN_YOUR_INSTANCE); return; } // just ignore us if(player->GetSocial()->HasIgnore(GetPlayer()->GetGUIDLow())) { SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_TARGET_IGNORE_YOU); return; } Group *group = GetPlayer()->GetGroup(); if( group && group->isBGGroup() ) group = GetPlayer()->GetOriginalGroup(); Group *group2 = player->GetGroup(); if( group2 && group2->isBGGroup() ) group2 = player->GetOriginalGroup(); // player already in another group or invited if( group2 || player->GetGroupInvite() ) { SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_ALREADY_IN_GROUP); return; } if(group) { // not have permissions for invite if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID())) { SendPartyResult(PARTY_OP_INVITE, "", PARTY_RESULT_YOU_NOT_LEADER); return; } // not have place if(group->IsFull()) { SendPartyResult(PARTY_OP_INVITE, "", PARTY_RESULT_PARTY_FULL); return; } } // ok, but group not exist, start a new group // but don't create and save the group to the DB until // at least one person joins if(!group) { group = new Group; // new group: if can't add then delete if(!group->AddLeaderInvite(GetPlayer())) { delete group; return; } if(!group->AddInvite(player)) { delete group; return; } } else { // already existed group: if can't add then just leave if(!group->AddInvite(player)) { return; } } // ok, we do it WorldPacket data(SMSG_GROUP_INVITE, 10); // guess size data << uint8(1); // ok data << GetPlayer()->GetName(); player->GetSession()->SendPacket(&data); SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_OK); }
// Test that setting an SkMemoryStream to a nullptr data does not result in a crash when calling // methods that access fData. static void TestDereferencingData(SkMemoryStream* memStream) { memStream->read(nullptr, 0); memStream->getMemoryBase(); sk_sp<SkData> data(memStream->copyToData()); }