src/game/ArenaTeam.cpp

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "WorldPacket.h"
  20 #include "ObjectMgr.h"
  21 #include "ArenaTeam.h"
  22
  23 ArenaTeam::ArenaTeam()
  24 {
  25     Id                  = 0;
  26     Type                = 0;
  27     Name                = "";
  28     CaptainGuid         = 0;
  29     BackgroundColor     = 0;                                // background
  30     EmblemStyle         = 0;                                // icon
  31     EmblemColor         = 0;                                // icon color
  32     BorderStyle         = 0;                                // border
  33     BorderColor         = 0;                                // border color
  34     stats.games_week    = 0;
  35     stats.games_season  = 0;
  36     stats.rank          = 0;
  37     stats.rating        = 1500;
  38     stats.wins_week     = 0;
  39     stats.wins_season   = 0;
  40 }
  41
  42 ArenaTeam::~ArenaTeam()
  43 {
  44
  45 }
  46
  47 bool ArenaTeam::Create(uint64 captainGuid, uint32 type, std::string ArenaTeamName)
  48 {
  49     if(!objmgr.GetPlayer(captainGuid))                      // player not exist
  50         return false;
  51     if(objmgr.GetArenaTeamByName(ArenaTeamName))            // arena team with this name already exist
  52         return false;
  53
  54     sLog.outDebug("GUILD: creating arena team %s to leader: %u", ArenaTeamName.c_str(), GUID_LOPART(captainGuid));
  55
  56     CaptainGuid = captainGuid;
  57     Name = ArenaTeamName;
  58     Type = type;
  59
  60     Id = objmgr.GenerateArenaTeamId();
  61
  62     // ArenaTeamName already assigned to ArenaTeam::name, use it to encode string for DB
  63     CharacterDatabase.escape_string(ArenaTeamName);
  64
  65     CharacterDatabase.BeginTransaction();
  66     // CharacterDatabase.PExecute("DELETE FROM arena_team WHERE arenateamid='%u'", Id); - MAX(arenateam)+1 not exist
  67     CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE arenateamid='%u'", Id);
  68     CharacterDatabase.PExecute("INSERT INTO arena_team (arenateamid,name,captainguid,type,BackgroundColor,EmblemStyle,EmblemColor,BorderStyle,BorderColor) "
  69         "VALUES('%u','%s','%u','%u','%u','%u','%u','%u','%u')",
  70         Id, ArenaTeamName.c_str(), GUID_LOPART(CaptainGuid), Type, BackgroundColor, EmblemStyle, EmblemColor, BorderStyle, BorderColor);
  71     CharacterDatabase.PExecute("INSERT INTO arena_team_stats (arenateamid, rating, games, wins, played, wins2, rank) VALUES "
  72         "('%u', '%u', '%u', '%u', '%u', '%u', '%u')", Id, stats.rating, stats.games_week, stats.wins_week, stats.games_season, stats.wins_season, stats.rank);
  73
  74     CharacterDatabase.CommitTransaction();
  75
  76     AddMember(CaptainGuid);
  77     return true;
  78 }
  79
  80 bool ArenaTeam::AddMember(const uint64& PlayerGuid)
  81 {
  82     std::string plName;
  83     uint8 plClass;
  84
  85     // arena team is full (can't have more than type * 2 players!)
  86     if(GetMembersSize() >= GetType() * 2)
  87         return false;
  88
  89     Player *pl = objmgr.GetPlayer(PlayerGuid);
  90     if(pl)
  91     {
  92         if(pl->GetArenaTeamId(GetSlot()))
  93         {
  94             sLog.outError("Arena::AddMember() : player already in this sized team");
  95             return false;
  96         }
  97
  98         plClass = (uint8)pl->getClass();
  99         plName = pl->GetName();
 100     }
 101     else
 102     {
 103         //                                                     0     1
 104         QueryResult *result = CharacterDatabase.PQuery("SELECT name, class FROM characters WHERE guid='%u'", GUID_LOPART(PlayerGuid));
 105         if(!result)
 106             return false;
 107
 108         plName = (*result)[0].GetCppString();
 109         plClass = (*result)[1].GetUInt8();
 110         delete result;
 111
 112         // check if player already in arenateam of that size
 113         if(Player::GetArenaTeamIdFromDB(PlayerGuid, GetType()) != 0)
 114         {
 115             sLog.outError("Arena::AddMember() : player already in this sized team");
 116             return false;
 117         }
 118     }
 119
 120     // remove all player signs from another petitions
 121     // this will be prevent attempt joining player to many arenateams and corrupt arena team data integrity
 122     Player::RemovePetitionsAndSigns(PlayerGuid, GetType());
 123
 124     ArenaTeamMember newmember;
 125     newmember.name              = plName;
 126     newmember.guid              = PlayerGuid;
 127     newmember.Class             = plClass;
 128     newmember.games_season      = 0;
 129     newmember.games_week        = 0;
 130     newmember.wins_season       = 0;
 131     newmember.wins_week         = 0;
 132     newmember.personal_rating   = 1500;
 133     members.push_back(newmember);
 134
 135     CharacterDatabase.PExecute("INSERT INTO arena_team_member (arenateamid, guid, personal_rating) VALUES ('%u', '%u', '%u')", Id, GUID_LOPART(newmember.guid), newmember.personal_rating );
 136
 137     if(pl)
 138     {
 139         pl->SetInArenaTeam(Id, GetSlot());
 140         pl->SetArenaTeamIdInvited(0);
 141         pl->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot()*6) + 5, newmember.personal_rating );
 142
 143         // hide promote/remove buttons
 144         if(CaptainGuid != PlayerGuid)
 145             pl->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * 6) + 1, 1);
 146     }
 147     return true;
 148 }
 149
 150 bool ArenaTeam::LoadArenaTeamFromDB(uint32 ArenaTeamId)
 151 {
 152     QueryResult *result = CharacterDatabase.PQuery("SELECT arenateamid,name,captainguid,type,BackgroundColor,EmblemStyle,EmblemColor,BorderStyle,BorderColor FROM arena_team WHERE arenateamid = '%u'", ArenaTeamId);
 153
 154     if(!result)
 155         return false;
 156
 157     Field *fields = result->Fetch();
 158
 159     Id = fields[0].GetUInt32();
 160     Name = fields[1].GetCppString();
 161     CaptainGuid  = MAKE_NEW_GUID(fields[2].GetUInt32(), 0, HIGHGUID_PLAYER);
 162     Type = fields[3].GetUInt32();
 163     BackgroundColor = fields[4].GetUInt32();
 164     EmblemStyle = fields[5].GetUInt32();
 165     EmblemColor = fields[6].GetUInt32();
 166     BorderStyle = fields[7].GetUInt32();
 167     BorderColor = fields[8].GetUInt32();
 168
 169     delete result;
 170
 171     // only load here, so additional checks can be made
 172     LoadStatsFromDB(ArenaTeamId);
 173     LoadMembersFromDB(ArenaTeamId);
 174
 175     if(Empty())
 176     {
 177         // arena team is empty, delete from db
 178         CharacterDatabase.BeginTransaction();
 179         CharacterDatabase.PExecute("DELETE FROM arena_team WHERE arenateamid = '%u'", ArenaTeamId);
 180         CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE arenateamid = '%u'", ArenaTeamId);
 181         CharacterDatabase.PExecute("DELETE FROM arena_team_stats WHERE arenateamid = '%u'", ArenaTeamId);
 182         CharacterDatabase.CommitTransaction();
 183         return false;
 184     }
 185
 186     return true;
 187 }
 188
 189 void ArenaTeam::LoadStatsFromDB(uint32 ArenaTeamId)
 190 {
 191     //                                                     0      1     2    3      4     5
 192     QueryResult *result = CharacterDatabase.PQuery("SELECT rating,games,wins,played,wins2,rank FROM arena_team_stats WHERE arenateamid = '%u'", ArenaTeamId);
 193
 194     if(!result)
 195         return;
 196
 197     Field *fields = result->Fetch();
 198
 199     stats.rating        = fields[0].GetUInt32();
 200     stats.games_week    = fields[1].GetUInt32();
 201     stats.wins_week     = fields[2].GetUInt32();
 202     stats.games_season  = fields[3].GetUInt32();
 203     stats.wins_season   = fields[4].GetUInt32();
 204     stats.rank          = fields[5].GetUInt32();
 205
 206     delete result;
 207 }
 208
 209 void ArenaTeam::LoadMembersFromDB(uint32 ArenaTeamId)
 210 {
 211     //                                                           0                1           2         3             4        5        6    7
 212     QueryResult *result = CharacterDatabase.PQuery("SELECT member.guid,played_week,wons_week,played_season,wons_season,personal_rating,name,class "
 213                                                    "FROM arena_team_member member "
 214                                                    "INNER JOIN characters chars on member.guid = chars.guid "
 215                                                    "WHERE member.arenateamid = '%u'", ArenaTeamId);
 216     if(!result)
 217         return;
 218
 219     do
 220     {
 221         Field *fields = result->Fetch();
 222         ArenaTeamMember newmember;
 223         newmember.guid          = MAKE_NEW_GUID(fields[0].GetUInt32(), 0, HIGHGUID_PLAYER);
 224         newmember.games_week    = fields[1].GetUInt32();
 225         newmember.wins_week     = fields[2].GetUInt32();
 226         newmember.games_season  = fields[3].GetUInt32();
 227         newmember.wins_season   = fields[4].GetUInt32();
 228         newmember.personal_rating = fields[5].GetUInt32();
 229         newmember.name          = fields[6].GetCppString();
 230         newmember.Class         = fields[7].GetUInt8();
 231         members.push_back(newmember);
 232     }while( result->NextRow() );
 233     delete result;
 234 }
 235
 236 void ArenaTeam::SetCaptain(const uint64& guid)
 237 {
 238     // disable remove/promote buttons
 239     Player *oldcaptain = objmgr.GetPlayer(GetCaptain());
 240     if(oldcaptain)
 241         oldcaptain->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 1 + (GetSlot() * 6), 1);
 242
 243     // set new captain
 244     CaptainGuid = guid;
 245
 246     // update database
 247     CharacterDatabase.PExecute("UPDATE arena_team SET captainguid = '%u' WHERE arenateamid = '%u'", GUID_LOPART(guid), Id);
 248
 249     // enable remove/promote buttons
 250     Player *newcaptain = objmgr.GetPlayer(guid);
 251     if(newcaptain)
 252         newcaptain->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 1 + (GetSlot() * 6), 0);
 253 }
 254
 255 void ArenaTeam::DelMember(uint64 guid)
 256 {
 257     for (MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
 258     {
 259         if (itr->guid == guid)
 260         {
 261             members.erase(itr);
 262             break;
 263         }
 264     }
 265
 266     Player *player = objmgr.GetPlayer(guid);
 267
 268     if(player)
 269     {
 270         player->SetInArenaTeam(0, GetSlot());
 271         player->GetSession()->SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, GetName(), "", 0);
 272         // delete all info regarding this team
 273         for(int i = 0; i < 6; ++i)
 274         {
 275             player->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * 6) + i, 0);
 276         }
 277     }
 278
 279     CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE arenateamid = '%u' AND guid = '%u'", GetId(), GUID_LOPART(guid));
 280 }
 281
 282 void ArenaTeam::Disband(WorldSession *session)
 283 {
 284     // event
 285     WorldPacket data;
 286     session->BuildArenaTeamEventPacket(&data, ERR_ARENA_TEAM_DISBANDED_S, 2, session->GetPlayerName(), GetName(), "");
 287     BroadcastPacket(&data);
 288
 289     while (!members.empty())
 290     {
 291         // Removing from members is done in DelMember.
 292         DelMember(members.front().guid);
 293     }
 294
 295     CharacterDatabase.BeginTransaction();
 296     CharacterDatabase.PExecute("DELETE FROM arena_team WHERE arenateamid = '%u'", Id);
 297     CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE arenateamid = '%u'", Id); //< this should be alredy done by calling DelMember(memberGuids[j]); for each member
 298     CharacterDatabase.PExecute("DELETE FROM arena_team_stats WHERE arenateamid = '%u'", Id);
 299     CharacterDatabase.CommitTransaction();
 300     objmgr.RemoveArenaTeam(Id);
 301 }
 302
 303 void ArenaTeam::Roster(WorldSession *session)
 304 {
 305     Player *pl = NULL;
 306
 307     uint8 unk308 = 0;
 308
 309     WorldPacket data(SMSG_ARENA_TEAM_ROSTER, 100);
 310     data << uint32(GetId());                                // arena team id
 311     data << uint8(unk308);                                  // 308 unknown value but affect packet structure
 312     data << uint32(GetMembersSize());                       // members count
 313     data << uint32(GetType());                              // arena team type?
 314
 315     for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 316     {
 317         pl = objmgr.GetPlayer(itr->guid);
 318
 319         data << uint64(itr->guid);                          // guid
 320         data << uint8((pl ? 1 : 0));                        // online flag
 321         data << itr->name;                                  // member name
 322         data << uint32((itr->guid == GetCaptain() ? 0 : 1));// captain flag 0 captain 1 member
 323         data << uint8((pl ? pl->getLevel() : 0));           // unknown, level?
 324         data << uint8(itr->Class);                          // class
 325         data << uint32(itr->games_week);                    // played this week
 326         data << uint32(itr->wins_week);                     // wins this week
 327         data << uint32(itr->games_season);                  // played this season
 328         data << uint32(itr->wins_season);                   // wins this season
 329         data << uint32(itr->personal_rating);               // personal rating
 330         if(unk308)
 331         {
 332             data << float(0.0);                             // 308 unk
 333             data << float(0.0);                             // 308 unk
 334         }
 335     }
 336
 337     session->SendPacket(&data);
 338     sLog.outDebug("WORLD: Sent SMSG_ARENA_TEAM_ROSTER");
 339 }
 340
 341 void ArenaTeam::Query(WorldSession *session)
 342 {
 343     WorldPacket data(SMSG_ARENA_TEAM_QUERY_RESPONSE, 4*7+GetName().size()+1);
 344     data << uint32(GetId());                                // team id
 345     data << GetName();                                      // team name
 346     data << uint32(GetType());                              // arena team type (2=2x2, 3=3x3 or 5=5x5)
 347     data << uint32(BackgroundColor);                        // background color
 348     data << uint32(EmblemStyle);                            // emblem style
 349     data << uint32(EmblemColor);                            // emblem color
 350     data << uint32(BorderStyle);                            // border style
 351     data << uint32(BorderColor);                            // border color
 352     session->SendPacket(&data);
 353     sLog.outDebug("WORLD: Sent SMSG_ARENA_TEAM_QUERY_RESPONSE");
 354 }
 355
 356 void ArenaTeam::Stats(WorldSession *session)
 357 {
 358     WorldPacket data(SMSG_ARENA_TEAM_STATS, 4*7);
 359     data << uint32(GetId());                                // arena team id
 360     data << uint32(stats.rating);                           // rating
 361     data << uint32(stats.games_week);                       // games this week
 362     data << uint32(stats.wins_week);                        // wins this week
 363     data << uint32(stats.games_season);                     // played this season
 364     data << uint32(stats.wins_season);                      // wins this season
 365     data << uint32(stats.rank);                             // rank
 366     session->SendPacket(&data);
 367 }
 368
 369 void ArenaTeam::NotifyStatsChanged()
 370 {
 371     // this is called after a rated match ended
 372     // updates arena team stats for every member of the team (not only the ones who participated!)
 373     for(MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 374     {
 375         Player * plr = objmgr.GetPlayer(itr->guid);
 376         if(plr)
 377             Stats(plr->GetSession());
 378     }
 379 }
 380
 381 void ArenaTeam::InspectStats(WorldSession *session, uint64 guid)
 382 {
 383     ArenaTeamMember* member = GetMember(guid);
 384     if(!member)
 385         return;
 386
 387     WorldPacket data(MSG_INSPECT_ARENA_TEAMS, 8+1+4*6);
 388     data << uint64(guid);                                   // player guid
 389     data << uint8(GetSlot());                               // slot (0...2)
 390     data << uint32(GetId());                                // arena team id
 391     data << uint32(stats.rating);                           // rating
 392     data << uint32(stats.games_season);                     // season played
 393     data << uint32(stats.wins_season);                      // season wins
 394     data << uint32(member->games_season);                   // played (count of all games, that the inspected member participated...)
 395     data << uint32(member->personal_rating);                // personal rating
 396     session->SendPacket(&data);
 397 }
 398
 399 void ArenaTeam::SetEmblem(uint32 backgroundColor, uint32 emblemStyle, uint32 emblemColor, uint32 borderStyle, uint32 borderColor)
 400 {
 401     BackgroundColor = backgroundColor;
 402     EmblemStyle = emblemStyle;
 403     EmblemColor = emblemColor;
 404     BorderStyle = borderStyle;
 405     BorderColor = borderColor;
 406
 407     CharacterDatabase.PExecute("UPDATE arena_team SET BackgroundColor='%u', EmblemStyle='%u', EmblemColor='%u', BorderStyle='%u', BorderColor='%u' WHERE arenateamid='%u'", BackgroundColor, EmblemStyle, EmblemColor, BorderStyle, BorderColor, Id);
 408 }
 409
 410 void ArenaTeam::SetStats(uint32 stat_type, uint32 value)
 411 {
 412     switch(stat_type)
 413     {
 414         case STAT_TYPE_RATING:
 415             stats.rating = value;
 416             CharacterDatabase.PExecute("UPDATE arena_team_stats SET rating = '%u' WHERE arenateamid = '%u'", value, GetId());
 417             break;
 418         case STAT_TYPE_GAMES_WEEK:
 419             stats.games_week = value;
 420             CharacterDatabase.PExecute("UPDATE arena_team_stats SET games = '%u' WHERE arenateamid = '%u'", value, GetId());
 421             break;
 422         case STAT_TYPE_WINS_WEEK:
 423             stats.wins_week = value;
 424             CharacterDatabase.PExecute("UPDATE arena_team_stats SET wins = '%u' WHERE arenateamid = '%u'", value, GetId());
 425             break;
 426         case STAT_TYPE_GAMES_SEASON:
 427             stats.games_season = value;
 428             CharacterDatabase.PExecute("UPDATE arena_team_stats SET played = '%u' WHERE arenateamid = '%u'", value, GetId());
 429             break;
 430         case STAT_TYPE_WINS_SEASON:
 431             stats.wins_season = value;
 432             CharacterDatabase.PExecute("UPDATE arena_team_stats SET wins2 = '%u' WHERE arenateamid = '%u'", value, GetId());
 433             break;
 434         case STAT_TYPE_RANK:
 435             stats.rank = value;
 436             CharacterDatabase.PExecute("UPDATE arena_team_stats SET rank = '%u' WHERE arenateamid = '%u'", value, GetId());
 437             break;
 438         default:
 439             sLog.outDebug("unknown stat type in ArenaTeam::SetStats() %u", stat_type);
 440             break;
 441     }
 442 }
 443
 444 void ArenaTeam::BroadcastPacket(WorldPacket *packet)
 445 {
 446     for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 447     {
 448         Player *player = objmgr.GetPlayer(itr->guid);
 449         if(player)
 450             player->GetSession()->SendPacket(packet);
 451     }
 452 }
 453
 454 uint8 ArenaTeam::GetSlotByType( uint32 type )
 455 {
 456     switch(type)
 457     {
 458         case ARENA_TEAM_2v2: return 0;
 459         case ARENA_TEAM_3v3: return 1;
 460         case ARENA_TEAM_5v5: return 2;
 461         default:
 462             break;
 463     }
 464     sLog.outError("FATAL: Unknown arena team type %u for some arena team", type);
 465     return 0xFF;
 466 }
 467
 468 bool ArenaTeam::HaveMember( const uint64& guid ) const
 469 {
 470     for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 471         if(itr->guid == guid)
 472             return true;
 473
 474     return false;
 475 }
 476
 477 uint32 ArenaTeam::GetPoints(uint32 MemberRating)
 478 {
 479     // returns how many points would be awarded with this team type with this rating
 480     float points;
 481
 482     uint32 rating = MemberRating + 150 < stats.rating ? MemberRating : stats.rating;
 483
 484     if(rating<=1500)
 485         points = (float)rating * 0.22f + 14.0f;
 486     else
 487         points = 1511.26f / (1.0f + 1639.28f * exp(-0.00412f * (float)rating));
 488
 489     // type penalties for <5v5 teams
 490     if(Type == ARENA_TEAM_2v2)
 491         points *= 0.76f;
 492     else if(Type == ARENA_TEAM_3v3)
 493         points *= 0.88f;
 494
 495     return (uint32) points;
 496 }
 497
 498 float ArenaTeam::GetChanceAgainst(uint32 own_rating, uint32 enemy_rating)
 499 {
 500     // returns the chance to win against a team with the given rating, used in the rating adjustment calculation
 501     // ELO system
 502     return 1.0f/(1.0f+exp(log(10.0f)*(float)((float)enemy_rating - (float)own_rating)/400.0f));
 503 }
 504
 505 int32 ArenaTeam::WonAgainst(uint32 againstRating)
 506 {
 507     // called when the team has won
 508     //'chance' calculation - to beat the opponent
 509     float chance = GetChanceAgainst(stats.rating,againstRating);
 510     // calculate the rating modification (ELO system with k=32)
 511     int32 mod = (int32)floor(32.0f * (1.0f - chance));
 512     // modify the team stats accordingly
 513     stats.rating += mod;
 514     stats.games_week += 1;
 515     stats.wins_week += 1;
 516     stats.games_season += 1;
 517     stats.wins_season += 1;
 518     //update team's rank
 519     stats.rank = 1;
 520     ObjectMgr::ArenaTeamMap::iterator i = objmgr.GetArenaTeamMapBegin();
 521     for ( ; i != objmgr.GetArenaTeamMapEnd(); ++i)
 522     {
 523         if (i->second->GetType() == this->Type && i->second->GetStats().rating > stats.rating)
 524             ++stats.rank;
 525     }
 526
 527     // return the rating change, used to display it on the results screen
 528     return mod;
 529 }
 530
 531 int32 ArenaTeam::LostAgainst(uint32 againstRating)
 532 {
 533     // called when the team has lost
 534     //'chance' calculation - to loose to the opponent
 535     float chance = GetChanceAgainst(stats.rating,againstRating);
 536     // calculate the rating modification (ELO system with k=32)
 537     int32 mod = (int32)ceil(32.0f * (0.0f - chance));
 538     // modify the team stats accordingly
 539     stats.rating += mod;
 540     stats.games_week += 1;
 541     stats.games_season += 1;
 542     //update team's rank
 543
 544     stats.rank = 1;
 545     ObjectMgr::ArenaTeamMap::iterator i = objmgr.GetArenaTeamMapBegin();
 546     for ( ; i != objmgr.GetArenaTeamMapEnd(); ++i)
 547     {
 548         if (i->second->GetType() == this->Type && i->second->GetStats().rating > stats.rating)
 549             ++stats.rank;
 550     }
 551
 552     // return the rating change, used to display it on the results screen
 553     return mod;
 554 }
 555
 556 void ArenaTeam::MemberLost(Player * plr, uint32 againstRating)
 557 {
 558     // called for each participant of a match after losing
 559     for(MemberList::iterator itr = members.begin(); itr !=  members.end(); ++itr)
 560     {
 561         if(itr->guid == plr->GetGUID())
 562         {
 563             // update personal rating
 564             float chance = GetChanceAgainst(itr->personal_rating, againstRating);
 565             int32 mod = (int32)ceil(32.0f * (0.0f - chance));
 566             itr->ModifyPersonalRating(plr, mod, GetSlot());
 567             // update personal played stats
 568             itr->games_week +=1;
 569             itr->games_season +=1;
 570             // update the unit fields
 571             plr->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 6 * GetSlot() + 2, itr->games_week);
 572             plr->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 6 * GetSlot() + 3, itr->games_season);
 573             return;
 574         }
 575     }
 576 }
 577
 578 void ArenaTeam::MemberWon(Player * plr, uint32 againstRating)
 579 {
 580     // called for each participant after winning a match
 581     for(MemberList::iterator itr = members.begin(); itr !=  members.end(); ++itr)
 582     {
 583         if(itr->guid == plr->GetGUID())
 584         {
 585             // update personal rating
 586             float chance = GetChanceAgainst(itr->personal_rating, againstRating);
 587             int32 mod = (int32)floor(32.0f * (1.0f - chance));
 588             itr->ModifyPersonalRating(plr, mod, GetSlot());
 589             // update personal stats
 590             itr->games_week +=1;
 591             itr->games_season +=1;
 592             itr->wins_season += 1;
 593             itr->wins_week += 1;
 594             // update unit fields
 595             plr->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 6 * GetSlot() + 2, itr->games_week);
 596             plr->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 6 * GetSlot() + 3, itr->games_season);
 597             return;
 598         }
 599     }
 600 }
 601
 602 void ArenaTeam::UpdateArenaPointsHelper(std::map<uint32, uint32>& PlayerPoints)
 603 {
 604     // called after a match has ended and the stats are already modified
 605     // helper function for arena point distribution (this way, when distributing, no actual calculation is required, just a few comparisons)
 606     // 10 played games per week is a minimum
 607     if (stats.games_week < 10)
 608         return;
 609     // to get points, a player has to participate in at least 30% of the matches
 610     uint32 min_plays = (uint32) ceil(stats.games_week * 0.3);
 611     for(MemberList::iterator itr = members.begin(); itr !=  members.end(); ++itr)
 612     {
 613         // the player participated in enough games, update his points
 614         uint32 points_to_add = 0;
 615         if (itr->games_week >= min_plays)
 616             points_to_add = GetPoints(itr->personal_rating);
 617         // OBSOLETE : CharacterDatabase.PExecute("UPDATE arena_team_member SET points_to_add = '%u' WHERE arenateamid = '%u' AND guid = '%u'", points_to_add, Id, itr->guid);
 618
 619         std::map<uint32, uint32>::iterator plr_itr = PlayerPoints.find(GUID_LOPART(itr->guid));
 620         if (plr_itr != PlayerPoints.end())
 621         {
 622             //check if there is already more points
 623             if (plr_itr->second < points_to_add)
 624                 PlayerPoints[GUID_LOPART(itr->guid)] = points_to_add;
 625         }
 626         else
 627             PlayerPoints[GUID_LOPART(itr->guid)] = points_to_add;
 628     }
 629 }
 630
 631 void ArenaTeam::SaveToDB()
 632 {
 633     // save team and member stats to db
 634     // called after a match has ended, or when calculating arena_points
 635     CharacterDatabase.PExecute("UPDATE arena_team_stats SET rating = '%u',games = '%u',played = '%u',rank = '%u',wins = '%u',wins2 = '%u' WHERE arenateamid = '%u'", stats.rating, stats.games_week, stats.games_season, stats.rank, stats.wins_week, stats.wins_season, GetId());
 636     for(MemberList::iterator itr = members.begin(); itr !=  members.end(); ++itr)
 637     {
 638         CharacterDatabase.PExecute("UPDATE arena_team_member SET played_week = '%u', wons_week = '%u', played_season = '%u', wons_season = '%u', personal_rating = '%u' WHERE arenateamid = '%u' AND guid = '%u'", itr->games_week, itr->wins_week, itr->games_season, itr->wins_season, itr->personal_rating, Id, itr->guid);
 639     }
 640 }
 641
 642 void ArenaTeam::FinishWeek()
 643 {
 644     stats.games_week = 0;                                   // played this week
 645     stats.wins_week = 0;                                    // wins this week
 646     for(MemberList::iterator itr = members.begin(); itr !=  members.end(); ++itr)
 647     {
 648         itr->games_week = 0;
 649         itr->wins_week = 0;
 650     }
 651 }
 652
 653 bool ArenaTeam::IsFighting() const
 654 {
 655     for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 656     {
 657         if (Player *p = objmgr.GetPlayer(itr->guid))
 658         {
 659             if (p->GetMap()->IsBattleArena())
 660                 return true;
 661         }
 662     }
 663     return false;
 664 }
 665
 666 /*
 667 arenateam fields (id from 2.3.3 client):
 668 1414 - arena team id 2v2
 669 1415 - 0=captain, 1=member
 670 1416 - played this week
 671 1417 - played this season
 672 1418 - unk - rank?
 673 1419 - personal arena rating
 674 1420 - arena team id 3v3
 675 1421 - 0=captain, 1=member
 676 1422 - played this week
 677 1423 - played this season
 678 1424 - unk - rank?
 679 1425 - personal arena rating
 680 1426 - arena team id 5v5
 681 1427 - 0=captain, 1=member
 682 1428 - played this week
 683 1429 - played this season
 684 1430 - unk - rank?
 685 1431 - personal arena rating
 686 */