自学教程：C++ DEBUG_LOG函数代码示例

void WorldSession::SendTrainerList(ObjectGuid guid, const std::string& strTitle){    DEBUG_LOG( "WORLD: SendTrainerList" );    Creature *unit = GetPlayer()->GetNPCIfCanInteractWith(guid,UNIT_NPC_FLAG_TRAINER);    if (!unit)    {        DEBUG_LOG("WORLD: SendTrainerList - %s not found or you can't interact with him.", guid.GetString().c_str());        return;    }    // remove fake death    if (GetPlayer()->hasUnitState(UNIT_STAT_DIED))        GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);    // trainer list loaded at check;    if (!unit->IsTrainerOf(_player,true))        return;    CreatureInfo const *ci = unit->GetCreatureInfo();    if (!ci)        return;    TrainerSpellData const* cSpells = unit->GetTrainerSpells();    TrainerSpellData const* tSpells = unit->GetTrainerTemplateSpells();    if (!cSpells && !tSpells)    {        DEBUG_LOG("WORLD: SendTrainerList - Training spells not found for %s", guid.GetString().c_str());        return;    }    uint32 maxcount = (cSpells ? cSpells->spellList.size() : 0) + (tSpells ? tSpells->spellList.size() : 0);    uint32 trainer_type = cSpells && cSpells->trainerType ? cSpells->trainerType : (tSpells ? tSpells->trainerType : 0);    WorldPacket data( SMSG_TRAINER_LIST, 8+4+4+maxcount*38 + strTitle.size()+1);    data << ObjectGuid(guid);    data << uint32(trainer_type);    size_t count_pos = data.wpos();    data << uint32(maxcount);    // reputation discount    float fDiscountMod = _player->GetReputationPriceDiscount(unit);    bool can_learn_primary_prof = GetPlayer()->GetFreePrimaryProfessionPoints() > 0;    uint32 count = 0;    if (cSpells)    {        for(TrainerSpellMap::const_iterator itr = cSpells->spellList.begin(); itr != cSpells->spellList.end(); ++itr)        {            TrainerSpell const* tSpell = &itr->second;            uint32 reqLevel = 0;            if(!_player->IsSpellFitByClassAndRace(tSpell->learnedSpell, &reqLevel))                continue;            reqLevel = tSpell->isProvidedReqLevel ? tSpell->reqLevel : std::max(reqLevel, tSpell->reqLevel);            TrainerSpellState state = _player->GetTrainerSpellState(tSpell, reqLevel);            SendTrainerSpellHelper(data, tSpell, state, fDiscountMod, can_learn_primary_prof, reqLevel);            ++count;        }    }    if (tSpells)    {        for(TrainerSpellMap::const_iterator itr = tSpells->spellList.begin(); itr != tSpells->spellList.end(); ++itr)        {            TrainerSpell const* tSpell = &itr->second;            uint32 reqLevel = 0;            if(!_player->IsSpellFitByClassAndRace(tSpell->learnedSpell, &reqLevel))                continue;            reqLevel = tSpell->isProvidedReqLevel ? tSpell->reqLevel : std::max(reqLevel, tSpell->reqLevel);            TrainerSpellState state = _player->GetTrainerSpellState(tSpell, reqLevel);            SendTrainerSpellHelper(data, tSpell, state, fDiscountMod, can_learn_primary_prof, reqLevel);            ++count;        }    }    data << strTitle;    data.put<uint32>(count_pos,count);    SendPacket(&data);}

void hleEnterVblank(u64 userdata, int cyclesLate) {	int vbCount = userdata;	DEBUG_LOG(SCEDISPLAY, "Enter VBlank %i", vbCount);	isVblank = 1;	vCount++; // vCount increases at each VBLANK.	hCountBase += hCountPerVblank; // This is the "accumulated" hcount base.	if (hCountBase > 0x7FFFFFFF) {		hCountBase -= 0x80000000;	}	frameStartTicks = CoreTiming::GetTicks();	// Wake up threads waiting for VBlank	u32 error;	for (size_t i = 0; i < vblankWaitingThreads.size(); i++) {		if (--vblankWaitingThreads[i].vcountUnblock == 0) {			// Only wake it if it wasn't already released by someone else.			SceUID waitID = __KernelGetWaitID(vblankWaitingThreads[i].threadID, WAITTYPE_VBLANK, error);			if (waitID == 1) {				__KernelResumeThreadFromWait(vblankWaitingThreads[i].threadID, 0);			}			vblankWaitingThreads.erase(vblankWaitingThreads.begin() + i--);		}	}	// Trigger VBlank interrupt handlers.	__TriggerInterrupt(PSP_INTR_IMMEDIATE | PSP_INTR_ONLY_IF_ENABLED | PSP_INTR_ALWAYS_RESCHED, PSP_VBLANK_INTR, PSP_INTR_SUB_ALL);	CoreTiming::ScheduleEvent(msToCycles(vblankMs) - cyclesLate, leaveVblankEvent, vbCount + 1);	gpuStats.numVBlanks++;	numVBlanksSinceFlip++;	// TODO: Should this be done here or in hleLeaveVblank?	if (framebufIsLatched) {		DEBUG_LOG(SCEDISPLAY, "Setting latched framebuffer %08x (prev: %08x)", latchedFramebuf.topaddr, framebuf.topaddr);		framebuf = latchedFramebuf;		framebufIsLatched = false;		gpu->SetDisplayFramebuffer(framebuf.topaddr, framebuf.pspFramebufLinesize, framebuf.pspFramebufFormat);	}	// We flip only if the framebuffer was dirty. This eliminates flicker when using	// non-buffered rendering. The interaction with frame skipping seems to need	// some work.	if (gpu->FramebufferDirty()) {		if (g_Config.iShowFPSCounter && g_Config.iShowFPSCounter < 4) {			CalculateFPS();		}		// Setting CORE_NEXTFRAME causes a swap.		// Check first though, might've just quit / been paused.		if (gpu->FramebufferReallyDirty()) {			if (coreState == CORE_RUNNING) {				coreState = CORE_NEXTFRAME;				gpu->CopyDisplayToOutput();				actualFlips++;			}		}		gpuStats.numFlips++;		bool throttle, skipFrame;		// 1.001f to compensate for the classic 59.94 NTSC framerate that the PSP seems to have.		DoFrameTiming(throttle, skipFrame, (float)numVBlanksSinceFlip * (1.001f / 60.0f));		int maxFrameskip = 8;		if (throttle) {			if (g_Config.iFrameSkip == 1) {				// 4 here means 1 drawn, 4 skipped - so 12 fps minimum.				maxFrameskip = 4;			} else {				maxFrameskip = g_Config.iFrameSkip - 1;			}		}		if (numSkippedFrames >= maxFrameskip) {			skipFrame = false;		}		if (skipFrame) {			gstate_c.skipDrawReason |= SKIPDRAW_SKIPFRAME;			numSkippedFrames++;		} else {			gstate_c.skipDrawReason &= ~SKIPDRAW_SKIPFRAME;			numSkippedFrames = 0;		}		// Returning here with coreState == CORE_NEXTFRAME causes a buffer flip to happen (next frame).		// Right after, we regain control for a little bit in hleAfterFlip. I think that's a great		// place to do housekeeping.		CoreTiming::ScheduleEvent(0 - cyclesLate, afterFlipEvent, 0);		numVBlanksSinceFlip = 0;	}}

void sceKernelSetGPO(u32 ledAddr){	// Sets debug LEDs.	DEBUG_LOG(HLE,"sceKernelSetGPO(%02x)", ledAddr);}

int sceKernelIcacheInvalidateRange(u32 addr, int size) {	DEBUG_LOG(HLE,"sceKernelIcacheInvalidateRange(%08x, %i)", addr, size);	// TODO: Make the JIT hash and compare the touched blocks.	return 0;}

void WorldSession::HandleBattleFieldPortOpcode(WorldPacket& recv_data){    DEBUG_LOG("WORLD: Received opcode CMSG_BATTLEFIELD_PORT");    uint8 type;                                             // arenatype if arena    uint8 unk2;                                             // unk, can be 0x0 (may be if was invited?) and 0x1    uint32 bgTypeId_;                                       // type id from dbc    uint16 unk;                                             // 0x1F90 constant?    uint8 action;                                           // enter battle 0x1, leave queue 0x0    recv_data >> type >> unk2 >> bgTypeId_ >> unk >> action;    if (!sBattlemasterListStore.LookupEntry(bgTypeId_))    {        sLog.outError("BattlegroundHandler: invalid bgtype (%u) received.", bgTypeId_);        return;    }    if (type && !IsArenaTypeValid(ArenaType(type)))    {        sLog.outError("BattlegroundHandler: Invalid CMSG_BATTLEFIELD_PORT received from player (%u), arena type wrong: %u.", _player->GetGUIDLow(), type);        return;    }    if (!_player->InBattleGroundQueue())    {        sLog.outError("BattlegroundHandler: Invalid CMSG_BATTLEFIELD_PORT received from player (%u), he is not in bg_queue.", _player->GetGUIDLow());        return;    }    // get GroupQueueInfo from BattleGroundQueue    BattleGroundTypeId bgTypeId = BattleGroundTypeId(bgTypeId_);    BattleGroundQueueTypeId bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(bgTypeId, ArenaType(type));    BattleGroundQueue& bgQueue = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId];    // we must use temporary variable, because GroupQueueInfo pointer can be deleted in BattleGroundQueue::RemovePlayer() function    GroupQueueInfo ginfo;    if (!bgQueue.GetPlayerGroupInfoData(_player->GetObjectGuid(), &ginfo))    {        sLog.outError("BattlegroundHandler: itrplayerstatus not found.");        return;    }    // if action == 1, then instanceId is required    if (!ginfo.IsInvitedToBGInstanceGUID && action == 1)    {        sLog.outError("BattlegroundHandler: instance not found.");        return;    }    BattleGround* bg = sBattleGroundMgr.GetBattleGround(ginfo.IsInvitedToBGInstanceGUID, bgTypeId);    // bg template might and must be used in case of leaving queue, when instance is not created yet    if (!bg && action == 0)        bg = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId);    if (!bg)    {        sLog.outError("BattlegroundHandler: bg_template not found for type id %u.", bgTypeId);        return;    }    // expected bracket entry    PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(), _player->getLevel());    if (!bracketEntry)        return;    // some checks if player isn't cheating - it is not exactly cheating, but we cannot allow it    if (action == 1 && ginfo.arenaType == ARENA_TYPE_NONE)    {        // if player is trying to enter battleground (not arena!) and he has deserter debuff, we must just remove him from queue        if (!_player->CanJoinToBattleground())        {            // send bg command result to show nice message            WorldPacket data2;            sBattleGroundMgr.BuildGroupJoinedBattlegroundPacket(&data2, ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS);            _player->GetSession()->SendPacket(&data2);            action = 0;            DEBUG_LOG("Battleground: player %s (%u) has a deserter debuff, do not port him to battleground!", _player->GetName(), _player->GetGUIDLow());        }        // if player don't match battleground max level, then do not allow him to enter! (this might happen when player leveled up during his waiting in queue        if (_player->getLevel() > bg->GetMaxLevel())        {            sLog.outError("Battleground: Player %s (%u) has level (%u) higher than maxlevel (%u) of battleground (%u)! Do not port him to battleground!",                          _player->GetName(), _player->GetGUIDLow(), _player->getLevel(), bg->GetMaxLevel(), bg->GetTypeID());            action = 0;        }    }    uint32 queueSlot = _player->GetBattleGroundQueueIndex(bgQueueTypeId);    WorldPacket data;    switch (action)    {        case 1:                                         // port to battleground            if (!_player->IsInvitedForBattleGroundQueueType(bgQueueTypeId))                return;                                 // cheating?            if (!_player->InBattleGround())                _player->SetBattleGroundEntryPoint();            // resurrect the player            if (!_player->isAlive())            {                _player->ResurrectPlayer(1.0f);//.........这里部分代码省略.........

void WorldSession::Handle_NULL(WorldPacket& recvPacket){    DEBUG_LOG("SESSION: received unimplemented opcode %s (0x%.4X)",              recvPacket.GetOpcodeName(),              recvPacket.GetOpcode());}

//.........这里部分代码省略.........        }        // 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);}

    CreatureAI* selectAI(Creature* creature)    {        const CreatureAICreator *ai_factory = NULL;        CreatureAIRegistry &ai_registry(CreatureAIRepository::Instance());        if (creature->isPet())            ai_factory = ai_registry.GetRegistryItem("PetAI");        //scriptname in db        if (!ai_factory)            if (CreatureAI* scriptedAI = sScriptMgr.GetAI(creature))                return scriptedAI;        // AIname in db        std::string ainame=creature->GetAIName();        if (!ai_factory && !ainame.empty())            ai_factory = ai_registry.GetRegistryItem(ainame.c_str());        // select by NPC flags        if (!ai_factory)        {            if (creature->HasSummonMask(SUMMON_MASK_CONTROLABLE_GUARDIAN) && ((Guardian*)creature)->GetOwner()->GetTypeId() == TYPEID_PLAYER)                ai_factory = ai_registry.GetRegistryItem("PetAI");            else if (creature->HasFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK))                ai_factory = ai_registry.GetRegistryItem("NullCreatureAI");            else if (creature->isGuard())                ai_factory = ai_registry.GetRegistryItem("GuardAI");            else if (creature->HasSummonMask(SUMMON_MASK_CONTROLABLE_GUARDIAN))                ai_factory = ai_registry.GetRegistryItem("PetAI");            else if (creature->isTotem())                ai_factory = ai_registry.GetRegistryItem("TotemAI");            else if (creature->isTrigger())            {                if (creature->m_spells[0])                    ai_factory = ai_registry.GetRegistryItem("TriggerAI");                else                    ai_factory = ai_registry.GetRegistryItem("NullCreatureAI");            }            else if (creature->GetCreatureType() == CREATURE_TYPE_CRITTER && !creature->HasSummonMask(SUMMON_MASK_GUARDIAN))                ai_factory = ai_registry.GetRegistryItem("CritterAI");        }        // select by permit check        if (!ai_factory)        {            int best_val = -1;            typedef CreatureAIRegistry::RegistryMapType RMT;            RMT const &l = ai_registry.GetRegisteredItems();            for (RMT::const_iterator iter = l.begin(); iter != l.end(); ++iter)            {                const CreatureAICreator *factory = iter->second;                const SelectableAI *p = dynamic_cast<const SelectableAI *>(factory);                ASSERT(p != NULL);                int val = p->Permit(creature);                if (val > best_val)                {                    best_val = val;                    ai_factory = p;                }            }        }        // select NullCreatureAI if not another cases        ainame = (ai_factory == NULL) ? "NullCreatureAI" : ai_factory->key();        DEBUG_LOG("Creature %u used AI is %s.", creature->GetGUIDLow(), ainame.c_str());        return (ai_factory == NULL ? new NullCreatureAI(creature) : ai_factory->Create(creature));    }

int main(int argc, char *argv[]) {#ifdef _NEED_WIN_GENERATE_DUMP	_oldWndExceptionFilter = SetUnhandledExceptionFilter(_exceptionFilter);#endif	InitOpenSSL _init;	settingsParseArgs(argc, argv);	for (int32 i = 0; i < argc; ++i) {		if (string("-fixprevious") == argv[i]) {			return psFixPrevious();		} else if (string("-cleanup") == argv[i]) {			return psCleanup();		}	}	logsInit();	Local::readSettings();	if (cFromAutoStart() && !cAutoStart()) {		psAutoStart(false, true);		Local::stop();		return 0;	}	DEBUG_LOG(("Application Info: Telegram started, test mode: %1, exe dir: %2").arg(logBool(cTestMode())).arg(cExeDir()));	if (cDebug()) {		LOG(("Application Info: Telegram started in debug mode"));		for (int32 i = 0; i < argc; ++i) {			LOG(("Argument: %1").arg(QString::fromLocal8Bit(argv[i])));		}        QStringList logs = psInitLogs();        for (int32 i = 0, l = logs.size(); i < l; ++i) {            LOG(("Init Log: %1").arg(logs.at(i)));        }    }    psClearInitLogs();	DEBUG_LOG(("Application Info: ideal thread count: %1, using %2 connections per session").arg(QThread::idealThreadCount()).arg(cConnectionsInSession()));	psStart();	int result = 0;	{		QByteArray args[] = { "-style=0" }; // prepare fake args		static const int a_cnt = sizeof(args) / sizeof(args[0]);		int a_argc = a_cnt + 1;		char *a_argv[a_cnt + 1] = { argv[0], args[0].data() };		Application app(a_argc, a_argv);		if (!App::quiting()) {			result = app.exec();		}	}    psFinish();	Local::stop();	DEBUG_LOG(("Application Info: Telegram done, result: %1").arg(result));	if (cRestartingUpdate()) {		DEBUG_LOG(("Application Info: executing updater to install update.."));		psExecUpdater();	} else if (cRestarting()) {		DEBUG_LOG(("Application Info: executing Telegram, because of restart.."));		psExecTelegram();	}	logsClose();	return result;}

Corpse*ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia){    Corpse *corpse = GetCorpseForPlayerGUID(player_guid);    if(!corpse)    {        //in fact this function is called from several places        //even when player doesn't have a corpse, not an error        //sLog.outError("Try remove corpse that not in map for GUID %ul", player_guid);        return NULL;    }    DEBUG_LOG("Deleting Corpse and spawning bones.");    // remove corpse from player_guid -> corpse map    RemoveCorpse(corpse);    // remove resurrectable corpse from grid object registry (loaded state checked into call)    // do not load the map if it's not loaded    Map *map = MapManager::Instance().FindMap(corpse->GetMapId(), corpse->GetInstanceId());    if(map)        map->Remove(corpse, false);    // remove corpse from DB    corpse->DeleteFromDB();    Corpse *bones = NULL;    // create the bones only if the map and the grid is loaded at the corpse's location    // ignore bones creating option in case insignia    if (map && (insignia ||        (map->IsBattleGroundOrArena() ? sWorld.getConfig(CONFIG_DEATH_BONES_BG_OR_ARENA) : sWorld.getConfig(CONFIG_DEATH_BONES_WORLD))) &&        !map->IsRemovalGrid(corpse->GetPositionX(), corpse->GetPositionY()))    {        // Create bones, don't change Corpse        bones = new Corpse;        bones->Create(corpse->GetGUIDLow());        for (int i = 3; i < CORPSE_END; ++i)                    // don't overwrite guid and object type            bones->SetUInt32Value(i, corpse->GetUInt32Value(i));        bones->SetGrid(corpse->GetGrid());        // bones->m_time = m_time;                              // don't overwrite time        // bones->m_inWorld = m_inWorld;                        // don't overwrite world state        // bones->m_type = m_type;                              // don't overwrite type        bones->Relocate(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ(), corpse->GetOrientation());        bones->SetPhaseMask(corpse->GetPhaseMask(), false);        bones->SetUInt32Value(CORPSE_FIELD_FLAGS, CORPSE_FLAG_UNK2 | CORPSE_FLAG_BONES);        bones->SetUInt64Value(CORPSE_FIELD_OWNER, 0);        for (int i = 0; i < EQUIPMENT_SLOT_END; ++i)        {            if(corpse->GetUInt32Value(CORPSE_FIELD_ITEM + i))                bones->SetUInt32Value(CORPSE_FIELD_ITEM + i, 0);        }        // add bones in grid store if grid loaded where corpse placed        map->Add(bones);    }    // all references to the corpse should be removed at this point    delete corpse;    return bones;}

void WorldSession::HandleBattlemasterJoinOpcode(WorldPacket& recv_data){    ObjectGuid guid;    uint32 bgTypeId_;    uint32 instanceId;    uint8 joinAsGroup;    bool isPremade = false;    Group* grp;    recv_data >> guid;                                      // battlemaster guid    recv_data >> bgTypeId_;                                 // battleground type id (DBC id)    recv_data >> instanceId;                                // instance id, 0 if First Available selected    recv_data >> joinAsGroup;                               // join as group    if (!sBattlemasterListStore.LookupEntry(bgTypeId_))    {        sLog.outError("Battleground: invalid bgtype (%u) received. possible cheater? player guid %u", bgTypeId_, _player->GetGUIDLow());        return;    }    BattleGroundTypeId bgTypeId = BattleGroundTypeId(bgTypeId_);    DEBUG_LOG("WORLD: Received opcode CMSG_BATTLEMASTER_JOIN from %s", guid.GetString().c_str());    // can do this, since it's battleground, not arena    BattleGroundQueueTypeId bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(bgTypeId, ARENA_TYPE_NONE);    // ignore if player is already in BG    if (_player->InBattleGround())        return;    // get bg instance or bg template if instance not found    BattleGround* bg = NULL;    if (instanceId)        bg = sBattleGroundMgr.GetBattleGroundThroughClientInstance(instanceId, bgTypeId);    if (!bg && !(bg = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId)))    {        sLog.outError("Battleground: no available bg / template found");        return;    }    // expected bracket entry    PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(), _player->getLevel());    if (!bracketEntry)        return;    GroupJoinBattlegroundResult err;    // check queue conditions    if (!joinAsGroup)    {        // check Deserter debuff        if (!_player->CanJoinToBattleground())        {            WorldPacket data;            sBattleGroundMgr.BuildGroupJoinedBattlegroundPacket(&data, ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS);            _player->GetSession()->SendPacket(&data);            return;        }        // check if already in queue        if (_player->GetBattleGroundQueueIndex(bgQueueTypeId) < PLAYER_MAX_BATTLEGROUND_QUEUES)            // player is already in this queue            return;        // check if has free queue slots        if (!_player->HasFreeBattleGroundQueueId())            return;    }    else    {        grp = _player->GetGroup();        // no group found, error        if (!grp)            return;        if (grp->GetLeaderGuid() != _player->GetObjectGuid())            return;        err = grp->CanJoinBattleGroundQueue(bg, bgQueueTypeId, 0, bg->GetMaxPlayersPerTeam(), false, 0);        isPremade = sWorld.getConfig(CONFIG_UINT32_BATTLEGROUND_PREMADE_GROUP_WAIT_FOR_MATCH) &&                    (grp->GetMembersCount() >= bg->GetMinPlayersPerTeam());    }    // if we're here, then the conditions to join a bg are met. We can proceed in joining.    // _player->GetGroup() was already checked, grp is already initialized    BattleGroundQueue& bgQueue = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId];    if (joinAsGroup)    {        GroupQueueInfo* ginfo = NULL;        uint32 avgTime = 0;        if (err > 0)        {            DEBUG_LOG("Battleground: the following players are joining as group:");            ginfo = bgQueue.AddGroup(_player, grp, bgTypeId, bracketEntry, ARENA_TYPE_NONE, false, isPremade, 0);            avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry->GetBracketId());        }        for (GroupReference* itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())        {            Player* member = itr->getSource();            if (!member)//.........这里部分代码省略.........

u32 sceKernelGetGPI(){	// Always returns 0 on production systems.	DEBUG_LOG(HLE,"0=sceKernelGetGPI()");	return 0;}

//.........这里部分代码省略.........			break;		case XFMEM_SETMATRIXINDB:			//_assert_msg_(GX_XF, 0, "XF matrixindex1");			VertexShaderManager::SetTexMatrixChangedB(newValue);			break;		case XFMEM_SETVIEWPORT:		case XFMEM_SETVIEWPORT+1:		case XFMEM_SETVIEWPORT+2:		case XFMEM_SETVIEWPORT+3:		case XFMEM_SETVIEWPORT+4:		case XFMEM_SETVIEWPORT+5:			VertexManagerBase::Flush();			VertexShaderManager::SetViewportChanged();			PixelShaderManager::SetViewportChanged();			GeometryShaderManager::SetViewportChanged();			nextAddress = XFMEM_SETVIEWPORT + 6;			break;		case XFMEM_SETPROJECTION:		case XFMEM_SETPROJECTION+1:		case XFMEM_SETPROJECTION+2:		case XFMEM_SETPROJECTION+3:		case XFMEM_SETPROJECTION+4:		case XFMEM_SETPROJECTION+5:		case XFMEM_SETPROJECTION+6:			VertexManagerBase::Flush();			VertexShaderManager::SetProjectionChanged();			GeometryShaderManager::SetProjectionChanged();			nextAddress = XFMEM_SETPROJECTION + 7;			break;		case XFMEM_SETNUMTEXGENS: // GXSetNumTexGens			if (xfmem.numTexGen.numTexGens != (newValue & 15))				VertexManagerBase::Flush();			break;		case XFMEM_SETTEXMTXINFO:		case XFMEM_SETTEXMTXINFO+1:		case XFMEM_SETTEXMTXINFO+2:		case XFMEM_SETTEXMTXINFO+3:		case XFMEM_SETTEXMTXINFO+4:		case XFMEM_SETTEXMTXINFO+5:		case XFMEM_SETTEXMTXINFO+6:		case XFMEM_SETTEXMTXINFO+7:			VertexManagerBase::Flush();			nextAddress = XFMEM_SETTEXMTXINFO + 8;			break;		case XFMEM_SETPOSMTXINFO:		case XFMEM_SETPOSMTXINFO+1:		case XFMEM_SETPOSMTXINFO+2:		case XFMEM_SETPOSMTXINFO+3:		case XFMEM_SETPOSMTXINFO+4:		case XFMEM_SETPOSMTXINFO+5:		case XFMEM_SETPOSMTXINFO+6:		case XFMEM_SETPOSMTXINFO+7:			VertexManagerBase::Flush();			nextAddress = XFMEM_SETPOSMTXINFO + 8;			break;		// --------------		// Unknown Regs		// --------------		// Maybe these are for Normals?		case 0x1048: //xfmem.texcoords[0].nrmmtxinfo.hex = data; break; ??		case 0x1049:		case 0x104a:		case 0x104b:		case 0x104c:		case 0x104d:		case 0x104e:		case 0x104f:			DEBUG_LOG(VIDEO, "Possible Normal Mtx XF reg?: %x=%x", address, newValue);			break;		case 0x1013:		case 0x1014:		case 0x1015:		case 0x1016:		case 0x1017:		default:			if (newValue != 0) // Ignore writes of zero.				WARN_LOG(VIDEO, "Unknown XF Reg: %x=%x", address, newValue);			break;		}		int transferred = nextAddress - address;		address = nextAddress;		transferSize -= transferred;		dataIndex += transferred;	}}

 int Ardb::GeoSearch(Context& ctx, RedisCommandFrame& cmd) {     GeoSearchOptions options;     std::string err;     if (0 != options.Parse(cmd.GetArguments(), err, 1))     {         fill_error_reply(ctx.reply, "%s", err.c_str());         return 0;     }     ValueObject meta;     int ret = GetMetaValue(ctx, cmd.GetArguments()[0], ZSET_META, meta);     CHECK_ARDB_RETURN_VALUE(ctx.reply, ret);     ctx.reply.type = REDIS_REPLY_ARRAY;     if (0 != ret)     {         return 0;     }     uint64 t1 = get_current_epoch_millis();     uint32 min_radius = 75; //magic number     if (options.asc && options.limit > 0 && options.offset == 0 && options.radius > min_radius)     {         uint32 old_radius = options.radius;         options.radius = min_radius;         do         {             ctx.reply.Clear();             int point_num = GeoSearchByOptions(ctx, meta, options);             if(point_num < 0)             {                 break;             }             if (options.radius == old_radius)             {                 break;             }             if (point_num > 0)             {                 if (point_num >= options.limit)                 {                     break;                 }                 options.radius *= sqrt((options.limit / point_num) + 1);             }             else             {                 options.radius *= 8;             }             if (options.radius > old_radius)             {                 options.radius = old_radius;             }         } while (options.radius <= old_radius);     }     else     {         GeoSearchByOptions(ctx, meta, options);     }     ctx.reply.type = REDIS_REPLY_ARRAY;     uint64 t2 = get_current_epoch_millis();     DEBUG_LOG("####Cost %llums to range geosearch", t2 - t1);     return 0; }

    int Ardb::GeoSearchByOptions(Context& ctx, ValueObject& meta, GeoSearchOptions& options)    {        uint64 start_time = get_current_epoch_micros();        int ret = 0;        double x = options.x, y = options.y;        if (options.by_member)        {            Data element, score;            element.SetString(options.member, true);            ret = ZSetScore(ctx, meta, element, score);            if (0 != ret || score.IsNil())            {                return -1;            }            GeoHashHelper::GetMercatorXYByHash(score.value.iv, x, y);        }        else        {            if (options.coord_type != GEO_MERCATOR_TYPE)            {                x = GeoHashHelper::GetMercatorX(options.x);                y = GeoHashHelper::GetMercatorY(options.y);            }        }        DEBUG_LOG("####Step1: Cost %lluus", get_current_epoch_micros() - start_time);        GeoPointArray points;        ZSetRangeByScoreOptions fetch_options;        fetch_options.withscores = false;        fetch_options.op = OP_GET;        fetch_options.fill_reply = false;        fetch_options.fetch_geo_location = true;        if (options.in_members)        {            StringSet::iterator it = options.submembers.begin();            while (it != options.submembers.end())            {                //GeoPoint point;                Data element, score;                element.SetString(*it, true);                Location loc;                ret = ZSetScore(ctx, meta, element, score, &loc);                if (0 == ret)                {                    fetch_options.results.push_back(element);                    //fetch_options.results.push_back(score);                    fetch_options.locs.push_back(loc);                }                it++;            }        }        else        {            GeoHashBitsSet ress;            GeoHashHelper::GetAreasByRadiusV2(GEO_MERCATOR_TYPE, y, x, options.radius, ress);            /*             * Merge areas if possible to avoid disk search             */            std::vector<ZRangeSpec> range_array;            GeoHashBitsSet::iterator rit = ress.begin();            typedef TreeMap<uint64, uint64>::Type HashRangeMap;            HashRangeMap tmp;            while (rit != ress.end())            {                GeoHashBits& hash = *rit;                GeoHashBits next = hash;                next.bits++;                tmp[GeoHashHelper::Allign60Bits(hash)] = GeoHashHelper::Allign60Bits(next);                rit++;            }            HashRangeMap::iterator tit = tmp.begin();            HashRangeMap::iterator nit = tmp.begin();            nit++;            while (tit != tmp.end())            {                ZRangeSpec range;                range.contain_min = true;                range.contain_max = true;                range.min.SetInt64(tit->first);                range.max.SetInt64(tit->second);                while (nit != tmp.end() && nit->first == range.max.value.iv)                {                    range.max.SetInt64(nit->second);                    nit++;                    tit++;                }                range_array.push_back(range);                nit++;                tit++;            }            DEBUG_LOG("After areas merging, reduce searching area size from %u to %u", ress.size(), range_array.size());            std::vector<ZRangeSpec>::iterator hit = range_array.begin();            ZSetIterator* iter = NULL;            while (hit != range_array.end())            {                ZRangeSpec& range = *hit;                uint64 t1 = get_current_epoch_millis();                ZSetRangeByScore(ctx, meta, range, fetch_options, iter);                uint64 t2 = get_current_epoch_millis();                DEBUG_LOG("####Cost %llums to range fetch", t2 - t1);//.........这里部分代码省略.........

/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/void WorldSession::HandleRequestPartyMemberStatsOpcode(WorldPacket& recv_data){    DEBUG_LOG("WORLD: Received opcode CMSG_REQUEST_PARTY_MEMBER_STATS");    ObjectGuid guid;    recv_data >> guid;    Player* player = ObjectAccessor::FindPlayer(guid, false);    if (!player)    {        WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3 + 4 + 2);        data << uint8(0);                                   // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related        data << guid.WriteAsPacked();        data << uint32(GROUP_UPDATE_FLAG_STATUS);        data << uint16(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 << uint8(0);                                       // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related    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 << uint16(GetGroupMemberStatus(player));           // member's online status    data << uint32(player->GetHealth());                    // GROUP_UPDATE_FLAG_CUR_HP    data << uint32(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    // verify player coordinates and zoneid to send to teammates    uint16 iZoneId = 0;    uint16 iCoordX = 0;    uint16 iCoordY = 0;    if (player->IsInWorld())    {        iZoneId = player->GetZoneId();        iCoordX = player->GetPositionX();        iCoordY = player->GetPositionY();    }    else if (player->IsBeingTeleported())               // Player is in teleportation    {        WorldLocation& loc = player->GetTeleportDest(); // So take teleportation destination        iZoneId = sTerrainMgr.GetZoneId(loc.mapid, loc.coord_x, loc.coord_y, loc.coord_z);        iCoordX = loc.coord_x;        iCoordY = loc.coord_y;    }    else    {        // unknown player status.    }    data << uint16(iZoneId);                              // GROUP_UPDATE_FLAG_ZONE    data << uint16(iCoordX);                              // GROUP_UPDATE_FLAG_POSITION    data << uint16(iCoordY);                              // GROUP_UPDATE_FLAG_POSITION    uint64 auramask = 0;    size_t maskPos = data.wpos();    data << uint64(auramask);                               // placeholder    for (uint8 i = 0; i < MAX_AURAS; ++i)    {        if (uint32 aura = player->GetVisibleAura(i))        {            auramask |= (uint64(1) << i);            data << uint32(aura);            data << uint8(1);        }    }    data.put<uint64>(maskPos, auramask);                    // GROUP_UPDATE_FLAG_AURAS    if (pet)    {        Powers petpowertype = pet->GetPowerType();        data << pet->GetObjectGuid();                       // GROUP_UPDATE_FLAG_PET_GUID        data << pet->GetName();                             // GROUP_UPDATE_FLAG_PET_NAME        data << uint16(pet->GetDisplayId());                // GROUP_UPDATE_FLAG_PET_MODEL_ID        data << uint32(pet->GetHealth());                   // GROUP_UPDATE_FLAG_PET_CUR_HP        data << uint32(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        uint64 petauramask = 0;        size_t petMaskPos = data.wpos();        data << uint64(petauramask);                        // placeholder        for (uint8 i = 0; i < MAX_AURAS; ++i)        {            if (uint32 petaura = pet->GetVisibleAura(i))            {                petauramask |= (uint64(1) << i);//.........这里部分代码省略.........

u32 sceDisplayIsVblank() {	DEBUG_LOG(SCEDISPLAY,"%i=sceDisplayIsVblank()",isVblank);	return isVblank;}