Ejemplo n.º 1
0
void ArenaTeam::MemberWon(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange)
{
    // called for each participant after winning a match
    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        if (itr->Guid == player->GetGUID())
        {
            // update personal rating
            int32 mod = GetRatingMod(itr->PersonalRating, againstMatchmakerRating, true);
            itr->ModifyPersonalRating(player, mod, GetType());

            // update matchmaker rating (pussywizard: but don't allow it to go over team rating)
            if (itr->MatchMakerRating < Stats.Rating)
            {
                mod = std::min(MatchmakerRatingChange, Stats.Rating - itr->MatchMakerRating);
                itr->ModifyMatchmakerRating(mod, GetSlot());
            }

            // update personal stats
            itr->WeekGames +=1;
            itr->SeasonGames +=1;
            itr->SeasonWins += 1;
            itr->WeekWins += 1;
            // update unit fields
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK, itr->WeekGames);
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON, itr->SeasonGames);
            return;
        }
    }
}
Ejemplo n.º 2
0
void ArenaTeam::MemberWon(Player * plr, uint32 againstRating)
{
    // called for each participant after winning a match
    for(MemberList::iterator itr = m_members.begin(); itr !=  m_members.end(); ++itr)
    {
        if (itr->guid == plr->GetObjectGuid())
        {
            // update personal rating
            float chance = GetChanceAgainst(itr->personal_rating, againstRating);
            float K = (itr->personal_rating < 1000) ? 48.0f : 32.0f;
            // calculate the rating modification (ELO system with k=32 or k=48 if rating<1000)
            int32 mod = (int32)floor(K* (1.0f - chance));
            itr->ModifyPersonalRating(plr, mod, GetSlot());
            // update personal stats
            itr->games_week += 1;
            itr->games_season += 1;
            itr->wins_season += 1;
            itr->wins_week += 1;
            // update unit fields
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK, itr->games_week);
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON, itr->games_season);
            return;
        }
    }
}
Ejemplo n.º 3
0
void ArenaTeam::MemberLost(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange)
{
    // Called for each participant of a match after losing
    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
    {
        if (itr->Guid == player->GetGUID())
        {
            // Update personal rating
            int32 mod = GetRatingMod(itr->PersonalRating, againstMatchmakerRating, false);
            itr->ModifyPersonalRating(player, mod, GetType());

            // Update matchmaker rating
            itr->ModifyMatchmakerRating(MatchmakerRatingChange, GetSlot());

            // Update personal played stats
            itr->WeekGames +=1;
            itr->SeasonGames +=1;

            // update the unit fields
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK,  itr->WeekGames);
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON,  itr->SeasonGames);
            return;
        }
    }
}
Ejemplo n.º 4
0
void ArenaTeam::MemberWon(Player * plr, uint32 againstMatchmakerRating, int32 teamratingchange)
{
    // called for each participant after winning a match
    for (MemberList::iterator itr = m_members.begin(); itr !=  m_members.end(); ++itr)
    {
        if (itr->guid == plr->GetGUID())
        {
            // update personal rating
            int32 mod = GetPersonalRatingMod(teamratingchange, (m_stats.rating - teamratingchange), itr->personal_rating);
            itr->ModifyPersonalRating(plr, mod, GetSlot());

            // update matchmaker rating
            mod = GetRatingMod(itr->matchmaker_rating, againstMatchmakerRating, true, true);
            itr->ModifyMatchmakerRating(mod, GetSlot());

            // update personal stats
            itr->games_week +=1;
            itr->games_season +=1;
            itr->wins_season += 1;
            itr->wins_week += 1;
            // update unit fields
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK, itr->games_week);
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON, itr->games_season);
            return;
        }
    }
}
Ejemplo n.º 5
0
int32 ArenaTeam::LostAgainst(uint32 againstRating, uint32 SoloQueueRating)
{
    // called when the team has lost
    // 'chance' calculation - to loose to the opponent
    float chance = GetChanceAgainst(SoloQueueRating > 0 ? SoloQueueRating : m_stats.rating, againstRating);
    // calculate the rating modification (ELO system with k=32)
    int32 mod = (int32)ceil((SoloQueueRating > 0 ? 16.0f : 32.0f) * (0.0f - chance));

    // Smolderforge rating adjustments
    if (GetType() == ARENA_TEAM_5v5) // solo queue
    {
        if (mod <= -15)
            mod = -14;

        // called for each participant of a match after losing
        for (MemberList::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
        {
            Player *plr = sObjectMgr->GetPlayer(itr->guid);
            if (plr)
                itr->ModifyPersonalRating(plr, mod, GetSlot());
        }
    }
    else if (GetType() == ARENA_TEAM_2v2)
    {
        if (mod <= -25)
            mod = -24;
    }

    // modify the team stats accordingly
    if (int32(m_stats.rating) + mod < 0)
        m_stats.rating = 0;
    else
        m_stats.rating += mod;

    // SOLOQUEUE - Don't track stats for lost games
    if (GetType() < ARENA_TEAM_5v5)
    {
        m_stats.games_week += 1;
        m_stats.games_season += 1;
    }

    // update team's rank
    m_stats.rank = 1;
    ObjectMgr::ArenaTeamMap::const_iterator i = sObjectMgr->GetArenaTeamMapBegin();
    for (; i != sObjectMgr->GetArenaTeamMapEnd(); ++i)
    {
        if (i->second->GetType() == m_Type && i->second->GetStats().rating > m_stats.rating)
            ++m_stats.rank;
    }

    // return the rating change, used to display it on the results screen
    return mod;
}
Ejemplo n.º 6
0
int32 ArenaTeam::WonAgainst(uint32 againstRating, uint32 SoloQueueRating)
{
    // called when the team has won
    // 'chance' calculation - to beat the opponent
    float chance = GetChanceAgainst(SoloQueueRating > 0 ? SoloQueueRating : m_stats.rating, againstRating);
    // calculate the rating modification (ELO system with k=32)
    int32 mod = (int32)floor((SoloQueueRating > 0 ? 16.0f : 32.0f) * (1.0f - chance));

    // Smolderforge rating adjustments
    if (GetType() == ARENA_TEAM_5v5) // solo queue
    {
        if (mod < 1)
            mod = 1;

        // called for each participant of a match after losing
        for (MemberList::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
        {
            Player *plr = sObjectMgr->GetPlayer(itr->guid);
            if (plr)
            {
                itr->ModifyPersonalRating(plr, mod, GetSlot());
                // update personal stats
                itr->games_week +=1;
                itr->games_season +=1;
                itr->wins_season += 1;
                itr->wins_week += 1;
                // update unit fields
                plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK, itr->games_week);
                plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON, itr->games_season);
            }
        }
    }
    else if (GetType() == ARENA_TEAM_2v2)
    {
        if (m_stats.rating < 1850)
            mod += 2;
        if (mod == 30)
            mod++;
        if (mod < 3)
            mod = 3;
    }

    // modify the team stats accordingly
    FinishGame(mod);
    m_stats.wins_week += 1;
    m_stats.wins_season += 1;

    // return the rating change, used to display it on the results screen
    return mod;
}
Ejemplo n.º 7
0
bool ClassHandler::get(Core::BaseObject *obj, void *n) {
	MemberNodeHandler *anyMemberHandler = NULL;
	bool anyIsOptional = true;

	for ( MemberList::iterator it = elements.begin();
	      it != elements.end(); ++it ) {
		if ( it->tag == "" ) {
			if ( anyMemberHandler == NULL ) {
				anyMemberHandler = &*it;
				anyIsOptional = it->optional;
			}
		}
		else if ( equalsTag(n, it->tag.c_str(), it->nameSpace.c_str()) ) {
			it->get(obj, n, this);
			isOptional = it->optional;
			memberHandler = &*it;
			return true;
		}
	}

	for ( MemberList::iterator it = childs.begin();
	      it != childs.end(); ++it ) {
		if ( it->tag == "" ) {
			if ( anyMemberHandler == NULL ) {
				anyMemberHandler = &*it;
				anyIsOptional = it->optional;
			}
		}
		else if ( equalsTag(n, it->tag.c_str(), it->nameSpace.c_str()) ) {
			it->get(obj, n, this);
			isOptional = it->optional;
			memberHandler = &*it;
			return true;
		}
	}

	if ( anyMemberHandler ) {
		memberHandler = anyMemberHandler;
		isOptional = anyIsOptional;
		isAnyType = true;
		return true;
	}

	return false;
}
Ejemplo n.º 8
0
void ArenaTeam::MemberWon(Player * plr, uint32 againstRating)
{
    // called for each participant after winning a match
    for(MemberList::iterator itr = m_members.begin(); itr !=  m_members.end(); ++itr)
    {
        if (itr->guid == plr->GetObjectGuid())
        {
            // FG: attempt to prevent "win trading" - dont give reward to winner if player with same IP is in opposite team
            Map::PlayerList const& plist = plr->GetMap()->GetPlayers();
            for(Map::PlayerList::const_iterator pit = plist.begin(); pit != plist.end(); ++pit)
            {
                Player *pp = pit->getSource();
                if( !(pp && pp->IsSessionValid() && plr->IsSessionValid()) )
                    return; // something wrong

                if(pp->GetSession()->GetIP() == plr->GetSession()->GetIP() && pp->IsHostileTo(plr))
                {
                    ChatHandler(plr).PSendSysMessage(11110, pp->GetName());
                    return;
                }
            }
            // FG: -end-

            // update personal rating
            float chance = GetChanceAgainst(itr->personal_rating, againstRating);
            float K = (itr->personal_rating < 1000) ? 48.0f : 32.0f;
            // calculate the rating modification (ELO system with k=32 or k=48 if rating<1000)
            int32 mod = (int32)floor(K* (1.0f - chance));
            itr->ModifyPersonalRating(plr, mod, GetSlot());
            // update personal stats
            itr->games_week += 1;
            itr->games_season += 1;
            itr->wins_season += 1;
            itr->wins_week += 1;
            // update unit fields
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK, itr->games_week);
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON, itr->games_season);
            return;
        }
    }
}
Ejemplo n.º 9
0
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;
        }
    }
}
Ejemplo n.º 10
0
void ArenaTeam::MemberLost(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
            float chance = GetChanceAgainst(itr->personal_rating, againstRating);
            int32 mod = (int32)ceil(32.0f * (0.0f - chance));
            itr->ModifyPersonalRating(plr, mod, GetSlot());
            // update personal played stats
            itr->games_week += 1;
            itr->games_season += 1;
            // update the unit fields
            plr->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * ARENA_TEAM_END) + ARENA_TEAM_GAMES_WEEK, itr->games_week);
            plr->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * ARENA_TEAM_END) + ARENA_TEAM_GAMES_SEASON, itr->games_season);
            return;
        }
    }
}
Ejemplo n.º 11
0
bool ClassHandler::init(Core::BaseObject *obj, void *n, TagSet &mandatory) {
	xmlNodePtr node = reinterpret_cast<xmlNodePtr>(n);

	// Fill in mandatory tags
	for ( MemberList::iterator it = attributes.begin();
	      it != attributes.end(); ++it ) {
		if ( !it->optional ) mandatory.insert(it->tag);
	}

	for ( MemberList::iterator it = elements.begin();
	      it != elements.end(); ++it ) {
		if ( !it->optional && !it->tag.empty() ) mandatory.insert(it->tag);
	}

	for ( MemberList::iterator it = childs.begin();
	      it != childs.end(); ++it ) {
		if ( !it->optional && !it->tag.empty() ) mandatory.insert(it->tag);
	}

	if ( cdataUsed )
		cdata.get(obj, n, this);

	if ( attributes.empty() ) return true;

	for ( xmlAttrPtr attr = node->properties; attr != NULL; attr = attr->next ) {
		if ( attr->children ) {
			for ( MemberList::iterator it = attributes.begin();
			      it != attributes.end(); ++it ) {
				if ( equalsTag(attr, it->tag.c_str(), it->nameSpace.c_str()) ) {
					if ( it->get(obj, attr, this) && !it->optional ) {
						mandatory.erase(it->tag);
						break;
					}
				}
			}
		}
	}

	return true;
}
Ejemplo n.º 12
0
void ArenaTeam::OfflineMemberLost(uint64 guid, uint32 againstMatchmakerRating, int32 teamratingchange)
{
    // called for offline player after ending rated arena match!
    for (MemberList::iterator itr = m_members.begin(); itr !=  m_members.end(); ++itr)
    {
        if (itr->guid == guid)
        {
            // update personal rating
            int32 mod = GetPersonalRatingMod(teamratingchange, itr->personal_rating, (m_stats.rating - teamratingchange));
            itr->ModifyPersonalRating(NULL, mod, GetSlot());

            // update matchmaker rating
            mod = GetRatingMod(itr->matchmaker_rating, againstMatchmakerRating, false, true);
            itr->ModifyMatchmakerRating(mod, GetSlot());

            // update personal played stats
            itr->games_week +=1;
            itr->games_season +=1;
            return;
        }
    }
}
Ejemplo n.º 13
0
void ArenaTeam::MemberWon(Player * plr, uint32 againstRating)
{
    // We handle personal rating for Solo Queue in Arena Team win or lost function
    if (GetType() == ARENA_TEAM_5v5)
        return;

    // called for each participant after winning a match
    for (MemberList::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
    {
        if (itr->guid == plr->GetGUID())
        {
            // update personal rating
            float chance = GetChanceAgainst(itr->personal_rating, againstRating);
            int32 mod = (int32)floor(32.0f * (1.0f - chance));

            if (GetType() == ARENA_TEAM_2v2)
            {
                if (m_stats.rating < 1850)
                    mod += 2;
                if (mod == 30)
                    mod++;
                if (mod < 3)
                    mod = 3;
            }

            itr->ModifyPersonalRating(plr, mod, GetSlot());
            // update personal stats
            itr->games_week +=1;
            itr->games_season +=1;
            itr->wins_season += 1;
            itr->wins_week += 1;
            // update unit fields
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK, itr->games_week);
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON, itr->games_season);
            return;
        }
    }
}
Ejemplo n.º 14
0
void ArenaTeam::MemberLost(Player * plr, uint32 againstRating)
{
    // We handle personal rating for Solo Queue in Arena Team win or lost function
    if (GetType() == ARENA_TEAM_5v5)
        return;

    // 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
            float chance = GetChanceAgainst(itr->personal_rating, againstRating);
            int32 mod = (int32)ceil(32.0f) * (0.0f - chance);

            // Smolderforge rating adjustments
            if (GetType() == ARENA_TEAM_2v2)
            {
                if (mod <= -25)
                    mod = -24;
            }

            itr->ModifyPersonalRating(plr, mod, GetSlot());

            // SOLOQUEUE - Don't track stats for lost games
            if (GetType() < ARENA_TEAM_5v5)
            {
                // update personal played stats
                itr->games_week += 1;
                itr->games_season += 1;
            }
            // update the unit fields
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK,  itr->games_week);
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON,  itr->games_season);
            return;
        }
    }
}
Ejemplo n.º 15
0
void ArenaTeam::MemberWon(Player * plr, uint32 againstRating)
{
    // called for each participant after winning a match
    for(MemberList::iterator itr = members.begin(); itr !=  members.end(); ++itr)
    {
        if(itr->guid == plr->GetGUID())
        {
            // update personal rating
            float chance = GetChanceAgainst(itr->personal_rating, againstRating);
            int32 mod = (int32)floor(32.0f * (1.0f - chance));
            itr->ModifyPersonalRating(plr, mod, GetSlot());
            // update personal stats
            itr->games_week +=1;
            itr->games_season +=1;
            itr->wins_season += 1;
            itr->wins_week += 1;
            // update unit fields
            plr->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 6 * GetSlot() + 2, itr->games_week);
            plr->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 6 * GetSlot() + 3, itr->games_season);
            return;
        }
    }
}
Ejemplo n.º 16
0
void ArenaTeam::MemberLost(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->GetObjectGuid())
        {
            // update personal rating
            float chance = GetChanceAgainst(itr->personal_rating, againstRating);
            float K = (itr->personal_rating < 1000) ? 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());

            // update matchmaker rating 
            chance = GetChanceAgainst(itr->matchmaker_rating, againstRating);
            K = (itr->matchmaker_rating < 1000) ? 48.0f : 32.0f;
            // calculate the rating modification (ELO system with k=32 or k=48 if rating<1000)
            mod = (int32)ceil(K * (0.0f - chance));
            itr->ModifyMatchmakerRating(plr,mod,GetType());

            // update personal played stats
            itr->games_week += 1;
            itr->games_season += 1;
            // update the unit fields
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK,  itr->games_week);
            plr->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON,  itr->games_season);
            return;
        }
    }
}
Ejemplo n.º 17
0
bool ClassHandler::put(Core::BaseObject *obj, const char *tag, const char *ns, OutputHandler *output) {
	if ( !output->openElement(tag, ns) ) return false;

	for ( MemberList::iterator it = attributes.begin();
	      it != attributes.end(); ++it ) {
		std::string v = it->value(obj);
		if ( v.empty() && it->optional ) continue;
		output->addAttribute(it->tag.c_str(), it->nameSpace.c_str(), v.c_str());
	}

	for ( MemberRefList::iterator it = orderedMembers.begin();
	      it != orderedMembers.end(); ++it ) {
		(*it)->put(obj, output, this);
	}

	/*
	for ( MemberList::iterator it = elements.begin();
	      it != elements.end(); ++it ) {
		it->put(obj, output, this);
	}

	for ( MemberList::iterator it = childs.begin();
	      it != childs.end(); ++it ) {
		it->put(obj, output, this);
	}
	*/

	if ( cdataUsed ) {
		std::string v = cdata.value(obj);
		if ( !v.empty() )
			output->put(v.c_str());
	}

	output->closeElement(tag, ns);

	return true;
}
Ejemplo n.º 18
0
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;
}
Ejemplo n.º 19
0
void ArenaTeam::MemberWon(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange)
{
    // called for each participant after winning a match
    for (MemberList::iterator itr = Members.begin(); itr !=  Members.end(); ++itr)
    {
        if (itr->Guid == player->GetGUID())
        {
            // update personal rating
            int32 mod = GetRatingMod(itr->PersonalRating, againstMatchmakerRating, true);
            itr->ModifyPersonalRating(player, mod, GetSlot());

            // update matchmaker rating
            itr->ModifyMatchmakerRating(MatchmakerRatingChange, GetSlot());

            // update personal stats
            itr->WeekGames +=1;
            itr->SeasonGames +=1;
            itr->SeasonWins += 1;
            itr->WeekWins += 1;
            // update unit fields
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_WEEK, itr->WeekGames);
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_GAMES_SEASON, itr->SeasonGames);
            return;

            //////////////////////////////////////////////////////
            //                                                  //
            //               CATACLYSM ARENA SYSTEM             //
            //  Winners receive fixed amount of Conquest Points //
            //                                                  //
            //                Losers, only Shame                //
            //                                                  //
            //////////////////////////////////////////////////////

            bool CapReached;

            switch (player->GetCurrency(390))     // Checks if Soft Cap has been reached, if yes, do not earn anymore points.
            {
                case 1343:
                case 1940:
                case 2533:
                case 2849:
                case 2964:
                case 3000:
                    CapReached = true;
                default:
                    CapReached = false;
            }

            if (CapReached == false)       // if not go ahead.
            {
                player->ModifyCurrency(390, 268.6f);

                // Conquest Point Soft Cap System - based on Personal Rating
                uint32 OldPoints = player->GetCurrency(390);
                uint32 OldRating = player->GetArenaPersonalRating(GetSlot());
                uint32 NewPoints = OldPoints;
                uint32 NewRating = OldRating;

                // First Check, points - Total Conquest Points cannot exceed the Soft Cap, So:
                if (OldRating <=1500 && OldPoints >= 1343)         // If this happens..
                {
                    NewPoints = 1343;                              // ..set points = Soft Cap, and set CapReached=1,
                                                                   // so player cannot earn anymore points until next week

                    // Second Check, rating - Rating has to remain the same
                    // for all the week, when a new week starts, rating can raise
                    // THIS IS TO AVOID RATING RAISING IN THE SAME WEEK.
                    // TODO: RATING RAISE WITHOUT EARNING POINTS.
                    if (Stats.WeekGames != 0 && OldRating > 1500)
                        NewRating = 1500;
                }

                // The same happens for all other brackets
                if ((OldRating > 1500 && OldRating < 1800) && OldPoints > 1940)
                {
                    NewPoints=1940;

                    if (Stats.WeekGames != 0 && OldRating > 1800)
                        NewRating = 1800;
                }

                if ((OldRating > 1800 && OldRating < 2100) && OldPoints > 2533)
                {
                    NewPoints = 2533;

                    if (Stats.WeekGames != 0 && OldRating > 2100)
                        NewRating = 2100;
                }
                if ((OldRating > 2100 && OldRating < 2400) && OldPoints > 2849)
                {
                    NewPoints = 2849;

                    if (Stats.WeekGames != 0 && OldRating > 2400)
                        NewRating = 2400;
                }
                if ((OldRating > 2400 && OldRating < 2700) && OldPoints > 2964)
                {
                    NewPoints = 2964;

                    if (Stats.WeekGames != 0 && OldRating > 3000)
                        NewRating = 3000;
                }
                if (OldRating >= 3000)
                    NewPoints = 3000;

                player->SetCurrency(390, NewPoints);
                itr->ModifyPersonalRating(player, NewRating, GetSlot());
            }
        }
    }
}