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;
}
}
}
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;
}
}
}
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;
}
}
}
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;
}
}
}
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;
}
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;
}
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;
}
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;
}
}
}
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 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;
}
}
}
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;
}
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;
}
}
}
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;
}
}
}
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;
}
}
}
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;
}
}
}
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;
}
}
}
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;
}
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 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());
}
}
}
}