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