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

void Item::UpdateDuration(Player* owner, uint32 diff){    if (!GetUInt32Value(ITEM_FIELD_DURATION))        return;    // DEBUG_LOG("Item::UpdateDuration Item (Entry: %u Duration %u Diff %u)", GetEntry(), GetUInt32Value(ITEM_FIELD_DURATION), diff);    if (GetUInt32Value(ITEM_FIELD_DURATION) <= diff)    {        if (uint32 newItemId = sObjectMgr.GetItemExpireConvert(GetEntry()))            owner->ConvertItem(this, newItemId);        else            owner->DestroyItem(GetBagSlot(), GetSlot(), true);        return;    }    SetUInt32Value(ITEM_FIELD_DURATION, GetUInt32Value(ITEM_FIELD_DURATION) - diff);    SetState(ITEM_CHANGED, owner);                          // save new time in database}

void ArenaTeam::DelMember(uint64 guid){    for (MemberList::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)        if (itr->guid == guid)        {            m_members.erase(itr);            break;        }    if (Player *player = sObjectMgr->GetPlayer(guid))    {        player->GetSession()->SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, GetName(), "", 0);        // delete all info regarding this team        for (uint32 i = 0; i < ARENA_TEAM_END; ++i)            player->SetArenaTeamInfoField(GetSlot(), ArenaTeamInfoType(i), 0);        sLog->outArena("Player: %s [GUID: %u] left arena team type: %u [Id: %u].", player->GetName(), player->GetGUIDLow(), GetType(), GetId());    }    CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE arenateamid = '%u' AND guid = '%u'", GetId(), GUID_LOPART(guid));}

bool CLatentEffect::Deactivate(){    if (IsActivated())    {        //remove the modifier from weapon, not player        if (GetModValue() == Mod::ADDITIONAL_EFFECT || GetModValue() == Mod::DMG)        {            CCharEntity* PChar = (CCharEntity*)m_POwner;			CItemWeapon* weapon = (CItemWeapon*)PChar->getEquip((SLOTTYPE)GetSlot());            int16 modPower = GetModPower();            if (weapon != nullptr && (weapon->isType(ITEM_ARMOR) || weapon->isType(ITEM_WEAPON)))            {                if (GetModValue() == Mod::ADDITIONAL_EFFECT)                {                    for (uint8 i = 0; i < weapon->modList.size(); ++i)                    {                        //ensure the additional effect is fully removed from the weapon                        if (weapon->modList.at(i).getModID() == Mod::ADDITIONAL_EFFECT)                        {                            weapon->modList.at(i).setModAmount(0);                        }                    }                }                else                {                    weapon->addModifier(CModifier(GetModValue(), -modPower));                }            }        }        else        {            m_POwner->delModifier(m_ModValue, m_ModPower);        }        m_Activated = false;        //printf("LATENT DEACTIVATED: %d/n", m_ModValue);        return true;    }    return false;}

void Item::UpdateDuration(Player* owner, uint32 diff){    if (!GetUInt32Value(ITEM_FIELD_DURATION))        return;#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)    sLog->outDebug(LOG_FILTER_PLAYER_ITEMS, "Item::UpdateDuration Item (Entry: %u Duration %u Diff %u)", GetEntry(), GetUInt32Value(ITEM_FIELD_DURATION), diff);#endif    if (GetUInt32Value(ITEM_FIELD_DURATION) <= diff)    {        sScriptMgr->OnItemExpire(owner, GetTemplate());        owner->DestroyItem(GetBagSlot(), GetSlot(), true);        return;    }    SetUInt32Value(ITEM_FIELD_DURATION, GetUInt32Value(ITEM_FIELD_DURATION) - diff);    SetState(ITEM_CHANGED, owner);                          // save new time in database}

void ArenaTeam::SaveToDB(){    // Save team and member stats to db    // Called after a match has ended or when calculating arena_points    SQLTransaction trans = CharacterDatabase.BeginTransaction();    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ARENA_TEAM_STATS);    stmt->setUInt16(0, Stats.Rating);    stmt->setUInt16(1, Stats.WeekGames);    stmt->setUInt16(2, Stats.WeekWins);    stmt->setUInt16(3, Stats.SeasonGames);    stmt->setUInt16(4, Stats.SeasonWins);    stmt->setUInt32(5, Stats.Rank);    stmt->setUInt32(6, GetId());    trans->Append(stmt);    for (MemberList::const_iterator itr = Members.begin(); itr != Members.end(); ++itr)    {        // Save the effort and go        if (itr->WeekGames == 0)            continue;        stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ARENA_TEAM_MEMBER);        stmt->setUInt16(0, itr->PersonalRating);        stmt->setUInt16(1, itr->WeekGames);        stmt->setUInt16(2, itr->WeekWins);        stmt->setUInt16(3, itr->SeasonGames);        stmt->setUInt16(4, itr->SeasonWins);        stmt->setUInt32(5, GetId());        stmt->setUInt32(6, itr->Guid.GetCounter());        trans->Append(stmt);        stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CHARACTER_ARENA_STATS);        stmt->setUInt32(0, itr->Guid.GetCounter());        stmt->setUInt8(1, GetSlot());        stmt->setUInt16(2, itr->MatchMakerRating);        trans->Append(stmt);    }    CharacterDatabase.CommitTransaction(trans);}

void cSlotArea::NumberClicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction){	if ((a_ClickAction < caNumber1) || (a_ClickAction > caNumber9))	{		return;	}	int HotbarSlot = (int)a_ClickAction - (int)caNumber1;	cItem ItemInHotbar(a_Player.GetInventory().GetHotbarSlot(HotbarSlot));	cItem ItemInSlot(*GetSlot(a_SlotNum, a_Player));	// The items are equal. Do nothing.	if (ItemInHotbar.IsEqual(ItemInSlot))	{		return;	}	a_Player.GetInventory().SetHotbarSlot(HotbarSlot, ItemInSlot);	SetSlot(a_SlotNum, a_Player, ItemInHotbar);}

VOIDCSDHCBase::PowerUp(                   ){    Validate();    for (DWORD dwSlot = 0; dwSlot < m_cSlots; ++dwSlot) {        PCSDHCSlotBase pSlot = GetSlot(dwSlot);        CEDEVICE_POWER_STATE cpsRequired = pSlot->GetPowerUpRequirement();        if (cpsRequired < m_cpsCurrent) {            // Move controller to higher power state initially since            // it will need to be powered for the slot to access            // registers.            SetControllerPowerState(cpsRequired);        }        pSlot->PowerUp();    }}

void cSlotAreaEnchanting::DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_Apply, bool a_KeepEmptySlots){	const cItem * Slot = GetSlot(0, a_Player);	if (!Slot->IsEmpty())	{		return;	}	if (a_Apply)	{		SetSlot(0, a_Player, a_ItemStack.CopyOne());	}	a_ItemStack.m_ItemCount -= 1;	if (a_ItemStack.m_ItemCount <= 0)	{		a_ItemStack.Empty();	}	UpdateResult(a_Player);}

void CGhost::StopRecord(int Time){	m_Recording = false;	bool RecordingToFile = GhostRecorder()->IsRecording();	if(RecordingToFile)		GhostRecorder()->Stop(m_CurGhost.m_Path.Size(), Time);	CMenus::CGhostItem *pOwnGhost = m_pClient->m_pMenus->GetOwnGhost();	if(Time > 0 && (!pOwnGhost || Time < pOwnGhost->m_Time))	{		if(pOwnGhost && pOwnGhost->Active())			Unload(pOwnGhost->m_Slot);		// add to active ghosts		int Slot = GetSlot();		if(Slot != -1)			m_aActiveGhosts[Slot] = std::move(m_CurGhost);		// create ghost item		CMenus::CGhostItem Item;		if(RecordingToFile)			GetPath(Item.m_aFilename, sizeof(Item.m_aFilename), m_CurGhost.m_aPlayer, Time);		str_copy(Item.m_aPlayer, m_CurGhost.m_aPlayer, sizeof(Item.m_aPlayer));		Item.m_Time = Time;		Item.m_Slot = Slot;		// save new ghost file		if(Item.HasFile())			Storage()->RenameFile(m_aTmpFilename, Item.m_aFilename, IStorage::TYPE_SAVE);		// add item to menu list		m_pClient->m_pMenus->UpdateOwnGhost(Item);	}	else if(RecordingToFile) // no new record		Storage()->RemoveFile(m_aTmpFilename, IStorage::TYPE_SAVE);	m_aTmpFilename[0] = 0;	m_CurGhost.Reset();}

void Item::UpdateDuration(Player* owner, uint32 diff){    if (!GetUInt32Value(ITEM_FIELD_DURATION))        return;    sLog.outDebug("Item::UpdateDuration Item (Entry: %u Duration %u Diff %u)",GetEntry(),GetUInt32Value(ITEM_FIELD_DURATION),diff);    if (GetUInt32Value(ITEM_FIELD_DURATION)<=diff)    {		uint32 itemId = this->GetEntry();		Script->ItemExpire(owner, GetProto());        owner->DestroyItem(GetBagSlot(), GetSlot(), true);           		ItemPosCountVec dest;		if (itemId == 39878) //Mysterious Egg        {            uint8 msg = owner->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, 39883, 1);            if (msg == EQUIP_ERR_OK)            {                Item* item = owner->StoreNewItem(dest,39883,true);                if (item)                    owner->SendNewItem(item,1,false,true);            }        }        if (itemId == 44717) //Disgusting Jar		{            uint8 msg = owner->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, 44718, 1);			if (msg == EQUIP_ERR_OK)			{                Item* item = owner->StoreNewItem(dest,44718,true);                if (item)                    owner->SendNewItem(item,1,false,true);            }        }        return;    }    SetUInt32Value(ITEM_FIELD_DURATION, GetUInt32Value(ITEM_FIELD_DURATION) - diff);    SetState(ITEM_CHANGED, owner);                          // save new time in database}

// New function to Card detect thread of HSMMC ch1 on SMDK6410.DWORD CSDHControllerCh1::CardDetectThread() {    BOOL  bSlotStateChanged = FALSE;    DWORD dwWaitResult  = WAIT_TIMEOUT;    PCSDHCSlotBase pSlotZero = GetSlot(0);    CeSetThreadPriority(GetCurrentThread(), 100);    while(1) {        // Wait for the next insertion/removal interrupt        dwWaitResult = WaitForSingleObject(m_hevCardDetectEvent, INFINITE);        Lock();        pSlotZero->HandleInterrupt(SDSLOT_INT_CARD_DETECTED);        Unlock();        InterruptDone(m_dwSDDetectSysIntr);        EnableCardDetectInterrupt();    }    return TRUE;}

void CLatentEffect::Activate(){    if( !IsActivated() )    {        //additional effect/dmg latents add mod to weapon, not player        if (GetModValue() == MOD_ADDITIONAL_EFFECT || GetModValue() == MOD_DMG)        {            CCharEntity* PChar = (CCharEntity*)m_POwner;            CItemWeapon* weapon = (CItemWeapon*)PChar->getEquip((SLOTTYPE)GetSlot());            weapon->addModifier(new CModifier(GetModValue(), GetModPower()));        }        else        {            m_POwner->addModifier(m_ModValue, m_ModPower);        }        m_Activated = true;        //printf("LATENT ACTIVATED: %d, Current value: %d/n", m_ModValue, m_POwner->getMod(m_ModValue));    }}

void Item::UpdateDuration(Player* owner, uint32 diff){    if (!GetUInt32Value(ITEM_FIELD_DURATION))        return;    //DEBUG_LOG("Item::UpdateDuration Item (Entry: %u Duration %u Diff %u)",GetEntry(),GetUInt32Value(ITEM_FIELD_DURATION),diff);    if (GetUInt32Value(ITEM_FIELD_DURATION)<=diff)    {        owner->DestroyItem(GetBagSlot(), GetSlot(), true);        return;    }    SetUInt32Value(ITEM_FIELD_DURATION, GetUInt32Value(ITEM_FIELD_DURATION) - diff);    SetState(ITEM_CHANGED, owner);                          // save new time in database    //Remove refundable flag for next time if item is no logner refundable    if(HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_REFUNDABLE))        if(!GetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME) || (GetOwner() && GetOwner()->m_Played_time[0] > (GetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME) + 2*60*60)))            RemoveFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_REFUNDABLE);}

void ArenaTeam::DelMember(ObjectGuid guid){    for (MemberList::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)    {        if (itr->guid == guid)        {            m_members.erase(itr);            break;        }    }    if(Player *player = sObjectMgr.GetPlayer(guid))    {        player->GetSession()->SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, GetName(), "", 0);        // delete all info regarding this team        for(int i = 0; i < ARENA_TEAM_END; ++i)            player->SetArenaTeamInfoField(GetSlot(), ArenaTeamInfoType(i), 0);    }    CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE arenateamid = '%u' AND guid = '%u'", GetId(), guid.GetCounter());}

void ArenaTeam::DelMember(uint64 guid){    for (MemberList::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)    {        if (itr->guid == guid)        {            m_members.erase(itr);            break;        }    }    if(Player *player = objmgr.GetPlayer(guid))    {        player->GetSession()->SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, GetName(), "", 0);        // delete all info regarding this team        for(int i = 0; i < ARENA_TEAM_END; ++i)            player->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * ARENA_TEAM_END) + i, 0);    }    CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE arenateamid = '%u' AND guid = '%u'", GetId(), GUID_LOPART(guid));}

void CInventoryItem::load(IReader &packet){	m_eItemPlace			= (EItemPlace)packet.r_u8();	m_fCondition			= packet.r_float();	SetSlot (packet.r_u8());	if (GetSlot() == 255)		SetSlot (NO_ACTIVE_SLOT);	u8						tmp = packet.r_u8();		if (!tmp)		return;		if (!object().PPhysicsShell()) {		object().setup_physic_shell	();		object().PPhysicsShell()->Disable();	}		object().PHLoadState(packet);	object().PPhysicsShell()->Disable();}

void ArenaTeam::OfflineMemberLost(uint64 guid, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange){    // Called for offline player after ending rated arena match!    for (MemberList::iterator itr = Members.begin(); itr !=  Members.end(); ++itr)    {        if (itr->Guid == guid)        {            // update personal rating            int32 mod = GetRatingMod(itr->PersonalRating, againstMatchmakerRating, false);            itr->ModifyPersonalRating(NULL, mod, GetType());            // update matchmaker rating            itr->ModifyMatchmakerRating(MatchmakerRatingChange, GetSlot());            // update personal played stats            itr->WeekGames += 1;            itr->SeasonGames += 1;            return;        }    }}

void cSlotAreaCrafting::ShiftClickedResult(cPlayer & a_Player){	cItem Result(*GetSlot(0, a_Player));	if (Result.IsEmpty())	{		return;	}	cItem * PlayerSlots = GetPlayerSlots(a_Player) + 1;	for (;;)	{		// Try distributing the result. If it fails, bail out:		cItem ResultCopy(Result);		m_ParentWindow.DistributeStack(ResultCopy, a_Player, this, false);		if (!ResultCopy.IsEmpty())		{			// Couldn't distribute all of it. Bail out			return;		}				// Distribute the result, this time for real:		ResultCopy = Result;		m_ParentWindow.DistributeStack(ResultCopy, a_Player, this, true);		// Remove the ingredients from the crafting grid and update the recipe:		cCraftingRecipe & Recipe = GetRecipeForPlayer(a_Player);		cCraftingGrid Grid(PlayerSlots, m_GridSize, m_GridSize);		Recipe.ConsumeIngredients(Grid);		Grid.CopyToItems(PlayerSlots);		UpdateRecipe(a_Player);		// Broadcast the window, we sometimes move items to different locations than Vanilla, causing needless desyncs:		m_ParentWindow.BroadcastWholeWindow();				// If the recipe has changed, bail out:		if (!Recipe.GetResult().IsEqual(Result))		{			return;		}	}}

int cInventory::HowManyCanFit(const cItem & a_ItemStack, int a_BeginSlotNum, int a_EndSlotNum, bool a_ConsiderEmptySlots){	UNUSED(a_ConsiderEmptySlots);	if ((a_BeginSlotNum < 0) || (a_BeginSlotNum >= invNumSlots))	{		LOGWARNING("%s: Bad BeginSlotNum, got %d, there are %d slots; correcting to 0.", __FUNCTION__, a_BeginSlotNum, invNumSlots - 1);		a_BeginSlotNum = 0;	}	if ((a_EndSlotNum < 0) || (a_EndSlotNum >= invNumSlots))	{		LOGWARNING("%s: Bad EndSlotNum, got %d, there are %d slots; correcting to %d.", __FUNCTION__, a_BeginSlotNum, invNumSlots, invNumSlots - 1);		a_EndSlotNum = invNumSlots - 1;	}	if (a_BeginSlotNum > a_EndSlotNum)	{		std::swap(a_BeginSlotNum, a_EndSlotNum);	}	char NumLeft = a_ItemStack.m_ItemCount;	int MaxStack = ItemHandler(a_ItemStack.m_ItemType)->GetMaxStackSize();	for (int i = a_BeginSlotNum; i <= a_EndSlotNum; i++)	{		const cItem & Slot = GetSlot(i);		if (Slot.IsEmpty())		{			NumLeft -= MaxStack;		}		else if (Slot.IsEqual(a_ItemStack))		{			NumLeft -= MaxStack - Slot.m_ItemCount;		}		if (NumLeft <= 0)		{			// All items fit			return a_ItemStack.m_ItemCount;		}	}  // for i - m_Slots[]	return a_ItemStack.m_ItemCount - NumLeft;}

void cWindow::OnRightPaintEnd(cPlayer & a_Player){	// Process the entire action stored in the internal structures for inventory painting	// distribute one item into each slot	const cSlotNums & SlotNums = a_Player.GetInventoryPaintSlots();	cItem ToDistribute(a_Player.GetDraggingItem());	int NumDistributed = DistributeItemToSlots(a_Player, ToDistribute, 1, SlotNums);	// Remove the items distributed from the dragging item:	a_Player.GetDraggingItem().m_ItemCount -= NumDistributed;	if (a_Player.GetDraggingItem().m_ItemCount == 0)	{		a_Player.GetDraggingItem().Empty();	}	SendWholeWindow(*a_Player.GetClientHandle());	// To fix #2345 (custom recipes don't work when inventory-painting), we send the result slot explicitly once again	// This is a fix for what seems like a client-side bug	a_Player.GetClientHandle()->SendInventorySlot(m_WindowID, 0, *GetSlot(a_Player, 0));}

void cSlotArea::DropClicked(cPlayer & a_Player, int a_SlotNum, bool a_DropStack){	cItem Slot(*GetSlot(a_SlotNum, a_Player));	if (Slot.IsEmpty())	{		return;	}	cItem ItemToDrop = Slot.CopyOne();	if (a_DropStack)	{		ItemToDrop.m_ItemCount = Slot.m_ItemCount;	}	Slot.m_ItemCount -= ItemToDrop.m_ItemCount;	if (Slot.m_ItemCount <= 0)	{		Slot.Empty();	}	SetSlot(a_SlotNum, a_Player, Slot);	a_Player.TossPickup(ItemToDrop);}

int32 ArenaTeam::MemberDraw(Player * plr, uint32 againstRating){    // called for each participant of a match after losing    for(MemberList::iterator itr = m_members.begin(); itr !=  m_members.end(); ++itr)    {        if (itr->guid == plr->GetGUID())        {            // update personal rating            // chance is always 0.5            float chance = 0.5f;            float K = (itr->personal_rating < 1500) ? 48.0f : 32.0f;            // calculate the rating modification (ELO system with k=32 or k=48 if rating<1000)            int32 mod = (int32)ceil(K * (0.0f - chance));            if (againstRating <= sWorld.getConfig(CONFIG_UINT32_LOSERNOCHANGE) || itr->personal_rating <= sWorld.getConfig(CONFIG_UINT32_LOSERNOCHANGE))                mod = 0;            else if (itr->personal_rating <= sWorld.getConfig(CONFIG_UINT32_LOSERHALFCHANGE))                mod /= 2;            itr->ModifyPersonalRating(plr, mod, GetSlot());            return mod;        }    }return 0;}

void cSlotAreaCrafting::ShiftClickedResult(cPlayer & a_Player){	cItem Result(*GetSlot(0, a_Player));	if (Result.IsEmpty())	{		return;	}	cItem * PlayerSlots = GetPlayerSlots(a_Player) + 1;	do	{		// Try distributing the result. If it fails, bail out:		cItem ResultCopy(Result);		m_ParentWindow.DistributeStack(ResultCopy, a_Player, this, false);		if (!ResultCopy.IsEmpty())		{			// Couldn't distribute all of it. Bail out			return;		}				// Distribute the result, this time for real:		ResultCopy = Result;		m_ParentWindow.DistributeStack(ResultCopy, a_Player, this, true);				// Remove the ingredients from the crafting grid and update the recipe:		cCraftingRecipe & Recipe = GetRecipeForPlayer(a_Player);		cCraftingGrid Grid(PlayerSlots, m_GridSize, m_GridSize);		Recipe.ConsumeIngredients(Grid);		Grid.CopyToItems(PlayerSlots);		UpdateRecipe(a_Player);		if (!Recipe.GetResult().IsEqual(Result))		{			// The recipe has changed, bail out			return;		}	} while (true);}

void ArenaTeam::SaveToDB(){    // save team and member stats to db    // called after a match has ended, or when calculating arena_points    SQLTransaction trans = CharacterDatabase.BeginTransaction();    trans->PAppend("UPDATE arena_team_stats SET rating = '%u',games = '%u',played = '%u',rank = '%u',wins = '%u',wins2 = '%u' WHERE arenateamid = '%u'", m_stats.rating, m_stats.games_week, m_stats.games_season, m_stats.rank, m_stats.wins_week, m_stats.wins_season, GetId());    for (MemberList::const_iterator itr = m_members.begin(); itr !=  m_members.end(); ++itr)    {        trans->PAppend("UPDATE arena_team_member SET played_week = '%u', wons_week = '%u', played_season = '%u', wons_season = '%u' WHERE arenateamid = '%u' AND guid = '%u'", itr->games_week, itr->wins_week, itr->games_season, itr->wins_season, m_TeamId, GUID_LOPART(itr->guid));        trans->PAppend("REPLACE INTO character_arena_stats (guid,slot,personal_rating,matchmaker_rating) VALUES ('%u', '%u', '%u', '%u')", GUID_LOPART(itr->guid), GetSlot(), itr->personal_rating, itr->matchmaker_rating);    }    CharacterDatabase.CommitTransaction(trans);}

bool ArenaTeam::LoadMembersFromDB(QueryResult arenaTeamMembersResult){    if (!arenaTeamMembersResult)        return false;    bool captainPresentInTeam = false;    do    {        Field *fields = arenaTeamMembersResult->Fetch();        //prevent crash if db records are broken, when all members in result are already processed and current team hasn't got any members        if (!fields)            break;        uint32 arenaTeamId        = fields[0].GetUInt32();        if (arenaTeamId < m_TeamId)        {            //there is in table arena_team_member record which doesn't have arenateamid in arena_team table, report error            sLog.outErrorDb("ArenaTeam %u does not exist but it has record in arena_team_member table, deleting it!", arenaTeamId);            CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE arenateamid = '%u'", arenaTeamId);            continue;        }        if (arenaTeamId > m_TeamId)            //we loaded all members for this arena_team already, break cycle            break;        uint32 player_guid = fields[1].GetUInt32();        QueryResult result = CharacterDatabase.PQuery(            "SELECT personal_rating, matchmaker_rating FROM character_arena_stats WHERE guid = '%u' AND slot = '%u'", player_guid, GetSlot());        uint32 personalrating = 0;        uint32 matchmakerrating = 1500;        if (result)        {            personalrating = (*result)[0].GetUInt32();            matchmakerrating = (*result)[1].GetUInt32();        }        ArenaTeamMember newmember;        newmember.guid              = MAKE_NEW_GUID(player_guid, 0, HIGHGUID_PLAYER);        newmember.games_week        = fields[2].GetUInt32();        newmember.wins_week         = fields[3].GetUInt32();        newmember.games_season      = fields[4].GetUInt32();        newmember.wins_season       = fields[5].GetUInt32();        newmember.name              = fields[6].GetString();        newmember.Class             = fields[7].GetUInt8();        newmember.personal_rating   = personalrating;        newmember.matchmaker_rating = matchmakerrating;        //check if member exists in characters table        if (newmember.name.empty())        {            sLog.outErrorDb("ArenaTeam %u has member with empty name - probably player %u doesn't exist, deleting him from memberlist!", arenaTeamId, GUID_LOPART(newmember.guid));            this->DelMember(newmember.guid);            continue;        }        if (newmember.guid == GetCaptain())            captainPresentInTeam = true;        m_members.push_back(newmember);    }while (arenaTeamMembersResult->NextRow());    if (Empty() || !captainPresentInTeam)    {        // arena team is empty or captain is not in team, delete from db        sLog.outErrorDb("ArenaTeam %u does not have any members or its captain is not in team, disbanding it...", m_TeamId);        return false;    }    return true;}

bool ArenaTeam::AddMember(const uint64& PlayerGuid){    std::string plName;    uint8 plClass;    uint32 plPRating;    uint32 plMMRating;    // arena team is full (can't have more than type * 2 players!)    if (GetMembersSize() >= GetType() * 2)        return false;    Player *pl = sObjectMgr.GetPlayer(PlayerGuid);    if (pl)    {        if (pl->GetArenaTeamId(GetSlot()))        {            sLog.outError("Arena::AddMember() : player already in this sized team");            return false;        }        plClass = pl->getClass();        plName = pl->GetName();    }    else    {        //                                                     0     1        QueryResult result = CharacterDatabase.PQuery("SELECT name, class FROM characters WHERE guid='%u'", GUID_LOPART(PlayerGuid));        if (!result)            return false;        plName = (*result)[0].GetString();        plClass = (*result)[1].GetUInt8();        // check if player already in arenateam of that size        if (Player::GetArenaTeamIdFromDB(PlayerGuid, GetType()) != 0)        {            sLog.outError("Arena::AddMember() : player already in this sized team");            return false;        }    }    plMMRating = sWorld.getIntConfig(CONFIG_ARENA_START_MATCHMAKER_RATING);    plPRating = 0;        if (sWorld.getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING) > 0)        plPRating = sWorld.getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING);    else if (GetRating() >= 1000)        plPRating = 1000;    sWorld.getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING);    QueryResult result = CharacterDatabase.PQuery("SELECT matchmaker_rating FROM character_arena_stats WHERE guid='%u' AND slot='%u'", GUID_LOPART(PlayerGuid), GetSlot());    if (result)        plMMRating = (*result)[0].GetUInt32();    // remove all player signs from another petitions    // this will be prevent attempt joining player to many arenateams and corrupt arena team data integrity    Player::RemovePetitionsAndSigns(PlayerGuid, GetType());    ArenaTeamMember newmember;    newmember.name              = plName;    newmember.guid              = PlayerGuid;    newmember.Class             = plClass;    newmember.games_season      = 0;    newmember.games_week        = 0;    newmember.wins_season       = 0;    newmember.wins_week         = 0;    newmember.personal_rating   = plPRating;    newmember.matchmaker_rating = plMMRating;    m_members.push_back(newmember);    CharacterDatabase.PExecute("INSERT INTO arena_team_member (arenateamid, guid) VALUES ('%u', '%u')", m_TeamId, GUID_LOPART(newmember.guid));    if (pl)    {        pl->SetInArenaTeam(m_TeamId, GetSlot(), GetType());        pl->SetArenaTeamIdInvited(0);        // hide promote/remove buttons        if (m_CaptainGuid != PlayerGuid)            pl->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 1);        sLog.outArena("Player: %s [GUID: %u] joined arena team type: %u [Id: %u].", pl->GetName(), pl->GetGUIDLow(), GetType(), GetId());    }    return true;}

bool ArenaTeam::AddMember(ObjectGuid playerGuid){    std::string playerName;    uint8 playerClass;    // Check if arena team is full (Can't have more than type * 2 players)    if (GetMembersSize() >= GetType() * 2)        return false;    // Get player name and class either from db or character cache    Player* player = ObjectAccessor::FindPlayer(playerGuid);    if (player)    {        playerClass = player->getClass();        playerName = player->GetName();    }    else    {        CharacterCacheEntry const* cInfo = sCharacterCache->GetCharacterCacheByGuid(playerGuid);        if (!cInfo)            return false;        playerName = cInfo->Name;        playerClass = cInfo->Class;    }    // Check if player is already in a similar arena team    if ((player && player->GetArenaTeamId(GetSlot())) || sCharacterCache->GetCharacterArenaTeamIdByGuid(playerGuid, GetType()) != 0)    {        TC_LOG_DEBUG("bg.arena", "Arena: %s %s already has an arena team of type %u", playerGuid.ToString().c_str(), playerName.c_str(), GetType());        return false;    }    // Set player's personal rating    uint32 personalRating = 0;    if (sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING) > 0)        personalRating = sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING);    else if (GetRating() >= 1000)        personalRating = 1000;    // Try to get player's match maker rating from db and fall back to config setting if not found    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MATCH_MAKER_RATING);    stmt->setUInt32(0, playerGuid.GetCounter());    stmt->setUInt8(1, GetSlot());    PreparedQueryResult result = CharacterDatabase.Query(stmt);    uint32 matchMakerRating;    if (result)        matchMakerRating = (*result)[0].GetUInt16();    else        matchMakerRating = sWorld->getIntConfig(CONFIG_ARENA_START_MATCHMAKER_RATING);    // Remove all player signatures from other petitions    // This will prevent player from joining too many arena teams and corrupt arena team data integrity    Player::RemovePetitionsAndSigns(playerGuid, static_cast<CharterTypes>(GetType()));    // Feed data to the struct    ArenaTeamMember newMember;    newMember.Name             = playerName;    newMember.Guid             = playerGuid;    newMember.Class            = playerClass;    newMember.SeasonGames      = 0;    newMember.WeekGames        = 0;    newMember.SeasonWins       = 0;    newMember.WeekWins         = 0;    newMember.PersonalRating   = personalRating;    newMember.MatchMakerRating = matchMakerRating;    Members.push_back(newMember);    sCharacterCache->UpdateCharacterArenaTeamId(playerGuid, GetSlot(), GetId());    // Save player's arena team membership to db    stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_TEAM_MEMBER);    stmt->setUInt32(0, TeamId);    stmt->setUInt32(1, playerGuid.GetCounter());    CharacterDatabase.Execute(stmt);    // Inform player if online    if (player)    {        player->SetInArenaTeam(TeamId, GetSlot(), GetType());        player->SetArenaTeamIdInvited(0);        // Hide promote/remove buttons        if (CaptainGuid != playerGuid)            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 1);    }    TC_LOG_DEBUG("bg.arena", "Player: %s [%s] joined arena team type: %u [Id: %u, Name: %s].", playerName.c_str(), playerGuid.ToString().c_str(), GetType(), GetId(), GetName().c_str());    return true;}

bool ArenaTeam::AddMember(const uint64& PlayerGuid){    std::string plName;    uint8 plClass;    // arena team is full (can't have more than type * 2 players!)    if(GetMembersSize() >= GetType() * 2)        return false;    Player *pl = objmgr.GetPlayer(PlayerGuid);    if(pl)    {        if(pl->GetArenaTeamId(GetSlot()))        {            sLog.outError("Arena::AddMember() : player already in this sized team");            return false;        }        plClass = pl->getClass();        plName = pl->GetName();    }    else    {        //                                                     0     1        QueryResult *result = CharacterDatabase.PQuery("SELECT name, class FROM characters WHERE guid='%u'", GUID_LOPART(PlayerGuid));        if(!result)            return false;        plName = (*result)[0].GetCppString();        plClass = (*result)[1].GetUInt8();        delete result;        // check if player already in arenateam of that size        if(Player::GetArenaTeamIdFromDB(PlayerGuid, GetType()) != 0)        {            sLog.outError("Arena::AddMember() : player already in this sized team");            return false;        }    }    // remove all player signs from another petitions    // this will be prevent attempt joining player to many arenateams and corrupt arena team data integrity    Player::RemovePetitionsAndSigns(PlayerGuid, GetType());    ArenaTeamMember newmember;    newmember.name              = plName;    newmember.guid              = PlayerGuid;    newmember.Class             = plClass;    newmember.games_season      = 0;    newmember.games_week        = 0;    newmember.wins_season       = 0;    newmember.wins_week         = 0;    if (sWorld.getConfig(CONFIG_ARENA_SEASON_ID) >= 6)    {        if (m_stats.rating < 1000)            newmember.personal_rating = m_stats.rating;        else            newmember.personal_rating = 1000;    }    else    {        newmember.personal_rating = 1500;    }    m_members.push_back(newmember);    CharacterDatabase.PExecute("INSERT INTO arena_team_member (arenateamid, guid, personal_rating) VALUES ('%u', '%u', '%u')", m_TeamId, GUID_LOPART(newmember.guid), newmember.personal_rating );    if(pl)    {        pl->SetInArenaTeam(m_TeamId, GetSlot(), GetType());        pl->SetArenaTeamIdInvited(0);        pl->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * ARENA_TEAM_END) + ARENA_TEAM_PERSONAL_RATING, newmember.personal_rating );        // hide promote/remove buttons        if(m_CaptainGuid != PlayerGuid)            pl->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * ARENA_TEAM_END) + ARENA_TEAM_MEMBER, 1);    }    return true;}

bool ArenaTeam::AddMember(const uint64& playerGuid){    std::string playerName;    uint8 playerClass;    // Check if arena team is full (Can't have more than type * 2 players)    if (GetMembersSize() >= GetType() * 2)        return false;    // Get player name and class either from db or ObjectMgr    Player* player = ObjectAccessor::FindPlayer(playerGuid);    if (player)    {        playerClass = player->getClass();        playerName = player->GetName();    }    else    {        //          0     1        // SELECT name, class FROM characters WHERE guid = ?        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHARACTER_SELECT_CHARACTER_NAME_CLASS);        stmt->setUInt32(0, GUID_LOPART(playerGuid));        PreparedQueryResult result = CharacterDatabase.Query(stmt);        if (!result)            return false;        playerName = (*result)[0].GetString();        playerClass = (*result)[1].GetUInt8();    }    // Check if player is already in a similar arena team    if ((player && player->GetArenaTeamId(GetSlot())) || Player::GetArenaTeamIdFromDB(playerGuid, GetType()) != 0)    {        sLog->outError("Arena: Player %s (guid: %u) already has an arena team of type %u", playerName.c_str(), GUID_LOPART(playerGuid), GetType());        return false;    }    // Set player's personal rating    uint32 personalRating = 0;    if (sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING) >= 0)        personalRating = sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING);    else if (GetRating() >= 1000)        personalRating = 1000;    // Try to get player's match maker rating from db and fall back to config setting if not found    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHARACTER_SELECT_MATCH_MAKER_RATING);    stmt->setUInt32(0, GUID_LOPART(playerGuid));    stmt->setUInt8(1, GetSlot());    PreparedQueryResult result = CharacterDatabase.Query(stmt);    uint32 matchMakerRating;    if (result)        matchMakerRating = (*result)[0].GetUInt32();    else        matchMakerRating = sWorld->getIntConfig(CONFIG_ARENA_START_MATCHMAKER_RATING);    // Remove all player signatures from other petitions    // This will prevent player from joining too many arena teams and corrupt arena team data integrity    Player::RemovePetitionsAndSigns(playerGuid, GetType());    // Feed data to the struct    ArenaTeamMember newmember;    newmember.Name             = playerName;    newmember.Guid             = playerGuid;    newmember.Class            = playerClass;    newmember.SeasonGames      = 0;    newmember.WeekGames        = 0;    newmember.SeasonWins       = 0;    newmember.WeekWins         = 0;    newmember.PersonalRating   = personalRating;    newmember.MatchMakerRating = matchMakerRating;    Members.push_back(newmember);    // Save player's arena team membership to db    stmt = CharacterDatabase.GetPreparedStatement(CHARACTER_INSERT_ARENA_TEAM_MEMBER);    stmt->setUInt32(0, TeamId);    stmt->setUInt32(1, GUID_LOPART(playerGuid));    CharacterDatabase.Execute(stmt);    // Inform player if online    if (player)    {        player->SetInArenaTeam(TeamId, GetSlot(), GetType());        player->SetArenaTeamIdInvited(0);        // Hide promote/remove buttons        if (CaptainGuid != playerGuid)            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 1);    }    sLog->outArena("Player: %s [GUID: %u] joined arena team type: %u [Id: %u].", playerName.c_str(), GUID_LOPART(playerGuid), GetType(), GetId());    return true;}

bool ArenaTeam::AddMember(ObjectGuid playerGuid){    std::string plName;    uint8 plClass;    // arena team is full (can't have more than type * 2 players!)    if (GetMembersSize() >= GetMaxMembersSize())        return false;    Player *pl = sObjectMgr.GetPlayer(playerGuid);    if (pl)    {        if (pl->GetArenaTeamId(GetSlot()))        {            sLog.outError("Arena::AddMember() : player already in this sized team");            return false;        }        plClass = pl->getClass();        plName = pl->GetName();    }    else    {        //                                                     0     1        QueryResult *result = CharacterDatabase.PQuery("SELECT name, class FROM characters WHERE guid='%u'", playerGuid.GetCounter());        if (!result)            return false;        plName = (*result)[0].GetCppString();        plClass = (*result)[1].GetUInt8();        delete result;        // check if player already in arenateam of that size        if (Player::GetArenaTeamIdFromDB(playerGuid, GetType()) != 0)        {            sLog.outError("Arena::AddMember() : player %s already in this sized team", playerGuid.GetString().c_str());            return false;        }    }    // remove all player signs from another petitions    // this will be prevent attempt joining player to many arenateams and corrupt arena team data integrity    Player::RemovePetitionsAndSigns(playerGuid, GetType());    ArenaTeamMember newmember;    newmember.name              = plName;    newmember.guid              = playerGuid;    newmember.Class             = plClass;    newmember.games_season      = 0;    newmember.games_week        = 0;    newmember.wins_season       = 0;    newmember.wins_week         = 0;    if (GetType() == ARENA_TYPE_2v2)    {        QueryResult *result = CharacterDatabase.PQuery("SELECT rating2 FROM hidden_rating WHERE guid='%u'", playerGuid.GetCounter());        if (!result)        {            CharacterDatabase.PExecute("INSERT INTO hidden_rating (guid, rating2, rating3, rating5) VALUES""('%u', '%u', '%u', '%u')", playerGuid.GetCounter(), 1500, 1500, 1500);            newmember.matchmaker_rating = 1500;        }        else        {            newmember.matchmaker_rating = (*result)[0].GetUInt32();            delete result;        }    }    if (GetType() == ARENA_TYPE_3v3)    {        QueryResult *result = CharacterDatabase.PQuery("SELECT rating3 FROM hidden_rating WHERE guid='%u'", playerGuid.GetCounter());        if (!result)        {            CharacterDatabase.PExecute("INSERT INTO hidden_rating (guid, rating2, rating3, rating5) VALUES""('%u', '%u', '%u', '%u')", playerGuid.GetCounter(), 1500, 1500, 1500);            newmember.matchmaker_rating = 1500;        }        else        {            newmember.matchmaker_rating = (*result)[0].GetUInt32();            delete result;        }    }    if (GetType() == ARENA_TYPE_5v5)    {        QueryResult *result = CharacterDatabase.PQuery("SELECT rating5 FROM hidden_rating WHERE guid='%u'", playerGuid.GetCounter());        if (!result)        {            CharacterDatabase.PExecute("INSERT INTO hidden_rating (guid, rating2, rating3, rating5) VALUES""('%u', '%u', '%u', '%u')", playerGuid.GetCounter(), 1500, 1500, 1500);            newmember.matchmaker_rating = 1500;        }        else        {            newmember.matchmaker_rating = (*result)[0].GetUInt32();            delete result;        }    }    int32 conf_value = sWorld.getConfig(CONFIG_INT32_ARENA_STARTPERSONALRATING);//.........这里部分代码省略.........