src/game/ArenaTeam.cpp

   1 /*
   2  * Copyright (C) 2005-2008 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(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) VALUES ('%u', '%u')", Id, GUID_LOPART(newmember.guid));
 136
 137     if(pl)
 138     {
 139         pl->SetInArenaTeam(Id, GetSlot());
 140         pl->SetArenaTeamIdInvited(0);
 141     }
 142     else
 143     {
 144         Player::SetUInt32ValueInDB(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * 6), Id, PlayerGuid);
 145     }
 146
 147     // hide promote/remove buttons
 148     if(CaptainGuid != PlayerGuid)
 149     {
 150         if(pl)
 151             pl->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 1 + (GetSlot() * 6), 1);
 152         else
 153             Player::SetUInt32ValueInDB(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 1 + (GetSlot() * 6), 1, PlayerGuid);
 154     }
 155     return true;
 156 }
 157
 158 bool ArenaTeam::LoadArenaTeamFromDB(uint32 ArenaTeamId)
 159 {
 160     LoadStatsFromDB(ArenaTeamId);
 161     LoadMembersFromDB(ArenaTeamId);
 162
 163     //                                                      0          1    2           3    4               5           6           7           8
 164     QueryResult *result = CharacterDatabase.PQuery("SELECT arenateamid,name,captainguid,type,BackgroundColor,EmblemStyle,EmblemColor,BorderStyle,BorderColor FROM arena_team WHERE arenateamid = '%u'", ArenaTeamId);
 165
 166     if(!result)
 167         return false;
 168
 169     Field *fields = result->Fetch();
 170
 171     Id = fields[0].GetUInt32();
 172     Name = fields[1].GetCppString();
 173     CaptainGuid  = MAKE_NEW_GUID(fields[2].GetUInt32(), 0, HIGHGUID_PLAYER);
 174     Type = fields[3].GetUInt32();
 175     BackgroundColor = fields[4].GetUInt32();
 176     EmblemStyle = fields[5].GetUInt32();
 177     EmblemColor = fields[6].GetUInt32();
 178     BorderStyle = fields[7].GetUInt32();
 179     BorderColor = fields[8].GetUInt32();
 180
 181     delete result;
 182
 183     return true;
 184 }
 185
 186 void ArenaTeam::LoadStatsFromDB(uint32 ArenaTeamId)
 187 {
 188     //                                                     0      1     2    3      4     5
 189     QueryResult *result = CharacterDatabase.PQuery("SELECT rating,games,wins,played,wins2,rank FROM arena_team_stats WHERE arenateamid = '%u'", ArenaTeamId);
 190
 191     if(!result)
 192         return;
 193
 194     Field *fields = result->Fetch();
 195
 196     stats.rating        = fields[0].GetUInt32();
 197     stats.games_week    = fields[1].GetUInt32();
 198     stats.wins_week     = fields[2].GetUInt32();
 199     stats.games_season  = fields[3].GetUInt32();
 200     stats.wins_season   = fields[4].GetUInt32();
 201     stats.rank          = fields[5].GetUInt32();
 202
 203     delete result;
 204 }
 205
 206 void ArenaTeam::LoadMembersFromDB(uint32 ArenaTeamId)
 207 {
 208     Field *fields;
 209
 210     QueryResult *result = CharacterDatabase.PQuery("SELECT guid,games_week,wins_week,games_season,wins_season FROM arena_team_member WHERE arenateamid = '%u'", ArenaTeamId);
 211     if(!result)
 212         return;
 213
 214     do
 215     {
 216         fields = result->Fetch();
 217         ArenaTeamMember newmember;
 218         newmember.guid          = MAKE_NEW_GUID(fields[0].GetUInt32(), 0, HIGHGUID_PLAYER);
 219         LoadPlayerStats(&newmember);
 220         newmember.games_week    = fields[1].GetUInt32();
 221         newmember.wins_week     = fields[2].GetUInt32();
 222         newmember.games_season  = fields[3].GetUInt32();
 223         newmember.wins_season   = fields[4].GetUInt32();
 224         members.push_back(newmember);
 225     }while( result->NextRow() );
 226     delete result;
 227 }
 228
 229 void ArenaTeam::LoadPlayerStats(ArenaTeamMember *member)
 230 {
 231     Field *fields;
 232
 233     QueryResult *result = CharacterDatabase.PQuery("SELECT name,class FROM characters WHERE guid = '%u'", GUID_LOPART(member->guid));
 234     if(!result)
 235         return;
 236     fields = result->Fetch();
 237     member->name  = fields[0].GetCppString();
 238     member->Class = fields[1].GetUInt8();
 239
 240     delete result;
 241 }
 242
 243 void ArenaTeam::SetCaptain(uint64 guid)
 244 {
 245     // disable remove/promote buttons
 246     Player *oldcaptain = objmgr.GetPlayer(GetCaptain());
 247     if(oldcaptain)
 248         oldcaptain->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 1 + (GetSlot() * 6), 1);
 249     else
 250         Player::SetUInt32ValueInDB(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 1 + (GetSlot() * 6), 1, GetCaptain());
 251
 252     // set new captain
 253     CaptainGuid = guid;
 254
 255     // update database
 256     CharacterDatabase.PExecute("UPDATE arena_team SET captainguid = '%u' WHERE arenateamid = '%u'", GUID_LOPART(guid), Id);
 257
 258     // enable remove/promote buttons
 259     Player *newcaptain = objmgr.GetPlayer(guid);
 260     if(newcaptain)
 261         newcaptain->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 1 + (GetSlot() * 6), 0);
 262     else
 263         Player::SetUInt32ValueInDB(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + 1 + (GetSlot() * 6), 0, guid);
 264 }
 265
 266 void ArenaTeam::DelMember(uint64 guid)
 267 {
 268     MemberList::iterator itr;
 269     for (itr = members.begin(); itr != members.end(); itr++)
 270     {
 271         if (itr->guid == guid)
 272         {
 273             members.erase(itr);
 274             break;
 275         }
 276     }
 277
 278     Player *player = objmgr.GetPlayer(guid);
 279     if(player)
 280     {
 281         player->SetInArenaTeam(0, GetSlot());
 282         player->GetSession()->SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, GetName(), "", 0);
 283     }
 284     else
 285     {
 286         Player::SetUInt32ValueInDB(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * 6), 0, guid);
 287     }
 288
 289     CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE guid = '%u'", GUID_LOPART(guid));
 290 }
 291
 292 void ArenaTeam::Disband(WorldSession *session)
 293 {
 294     // event
 295     WorldPacket data;
 296     session->BuildArenaTeamEventPacket(&data, ERR_ARENA_TEAM_DISBANDED_S, 2, session->GetPlayerName(), GetName(), "");
 297     BroadcastPacket(&data);
 298
 299     uint32 count = members.size();
 300     uint64 *memberGuids = new uint64[count];
 301
 302     MemberList::iterator itr;
 303     uint32 i=0;
 304     for(itr = members.begin(); itr != members.end(); itr++)
 305     {
 306         memberGuids[i] = itr->guid;
 307         ++i;
 308     }
 309
 310     for(uint32 j = 0; j < count; j++)
 311         DelMember(memberGuids[j]);
 312     delete[] memberGuids;
 313
 314     CharacterDatabase.BeginTransaction();
 315     CharacterDatabase.PExecute("DELETE FROM arena_team WHERE arenateamid = '%u'", Id);
 316     CharacterDatabase.PExecute("DELETE FROM arena_team_stats WHERE arenateamid = '%u'", Id);
 317     CharacterDatabase.CommitTransaction();
 318     objmgr.RemoveArenaTeam(this);
 319 }
 320
 321 void ArenaTeam::Roster(WorldSession *session)
 322 {
 323     Player *pl = NULL;
 324
 325     WorldPacket data(SMSG_ARENA_TEAM_ROSTER, 100);
 326     data << uint32(GetId());                                // arena team id
 327     data << uint32(GetMembersSize());                       // members count
 328     data << uint32(GetType());                              // arena team type?
 329
 330     for (MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
 331     {
 332         pl = objmgr.GetPlayer(itr->guid);
 333         if(pl)
 334         {
 335             data << uint64(pl->GetGUID());                  // guid
 336             data << uint8(1);                               // online flag
 337             data << pl->GetName();                          // member name
 338             data << uint32(itr->guid == GetCaptain() ? 0 : 1);// unknown
 339             data << uint8(pl->getLevel());                  // unknown, probably level
 340             data << uint8(pl->getClass());                  // class
 341             data << uint32(itr->games_week);                // played this week
 342             data << uint32(itr->wins_week);                 // wins this week
 343             data << uint32(itr->games_season);              // played this season
 344             data << uint32(itr->wins_season);               // wins this season
 345             data << uint32(itr->personal_rating);           // personal rating
 346         }
 347         else
 348         {
 349             data << uint64(itr->guid);                      // guid
 350             data << uint8(0);                               // online flag
 351             data << itr->name;                              // member name
 352             data << uint32(itr->guid == GetCaptain() ? 0 : 1);// unknown
 353             data << uint8(0);                               // unknown, level?
 354             data << uint8(itr->Class);                      // class
 355             data << uint32(itr->games_week);                // played this week
 356             data << uint32(itr->wins_week);                 // wins this week
 357             data << uint32(itr->games_season);              // played this season
 358             data << uint32(itr->wins_season);               // wins this season
 359             data << uint32(itr->personal_rating);           // personal rating
 360         }
 361     }
 362     session->SendPacket(&data);
 363     sLog.outDebug("WORLD: Sent SMSG_ARENA_TEAM_ROSTER");
 364 }
 365
 366 void ArenaTeam::Query(WorldSession *session)
 367 {
 368     WorldPacket data(SMSG_ARENA_TEAM_QUERY_RESPONSE, 4*7+GetName().size()+1);
 369     data << uint32(GetId());                                // team id
 370     data << GetName();                                      // team name
 371     data << uint32(GetType());                              // arena team type (2=2x2, 3=3x3 or 5=5x5)
 372     data << uint32(BackgroundColor);                        // background color
 373     data << uint32(EmblemStyle);                            // emblem style
 374     data << uint32(EmblemColor);                            // emblem color
 375     data << uint32(BorderStyle);                            // border style
 376     data << uint32(BorderColor);                            // border color
 377     session->SendPacket(&data);
 378     sLog.outDebug("WORLD: Sent SMSG_ARENA_TEAM_QUERY_RESPONSE");
 379 }
 380
 381 void ArenaTeam::Stats(WorldSession *session)
 382 {
 383     WorldPacket data(SMSG_ARENA_TEAM_STATS, 4*7);
 384     data << uint32(GetId());                                // arena team id
 385     data << uint32(stats.rating);                           // rating
 386     data << uint32(stats.games_week);                       // games this week
 387     data << uint32(stats.wins_week);                        // wins this week
 388     data << uint32(stats.games_season);                     // played this season
 389     data << uint32(stats.wins_season);                      // wins this season
 390     data << uint32(stats.rank);                             // rank
 391     session->SendPacket(&data);
 392 }
 393
 394 void ArenaTeam::InspectStats(WorldSession *session, uint64 guid)
 395 {
 396     ArenaTeamMember* member = GetMember(guid);
 397     if(!member)
 398         return;
 399
 400     WorldPacket data(MSG_INSPECT_ARENA_TEAMS, 8+1+4*6);
 401     data << uint64(guid);                                   // player guid
 402     data << uint8(GetSlot());                               // slot (0...2)
 403     data << uint32(GetId());                                // arena team id
 404     data << uint32(stats.rating);                           // rating
 405     data << uint32(stats.games_season);                     // season played
 406     data << uint32(stats.wins_season);                      // season wins
 407     data << member->games_season;                           // played (count of all games, that the inspected member participated...)
 408     data << member->personal_rating;                        // personal rating
 409     session->SendPacket(&data);
 410 }
 411
 412 void ArenaTeam::SetEmblem(uint32 backgroundColor, uint32 emblemStyle, uint32 emblemColor, uint32 borderStyle, uint32 borderColor)
 413 {
 414     BackgroundColor = backgroundColor;
 415     EmblemStyle = emblemStyle;
 416     EmblemColor = emblemColor;
 417     BorderStyle = borderStyle;
 418     BorderColor = borderColor;
 419
 420     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);
 421 }
 422
 423 void ArenaTeam::SetStats(uint32 stat_type, uint32 value)
 424 {
 425     switch(stat_type)
 426     {
 427         case STAT_TYPE_RATING:
 428             stats.rating = value;
 429             CharacterDatabase.PExecute("UPDATE arena_team_stats SET rating = '%u' WHERE arenateamid = '%u'", value, GetId());
 430             break;
 431         case STAT_TYPE_GAMES_WEEK:
 432             stats.games_week = value;
 433             CharacterDatabase.PExecute("UPDATE arena_team_stats SET games = '%u' WHERE arenateamid = '%u'", value, GetId());
 434             break;
 435         case STAT_TYPE_WINS_WEEK:
 436             stats.wins_week = value;
 437             CharacterDatabase.PExecute("UPDATE arena_team_stats SET wins = '%u' WHERE arenateamid = '%u'", value, GetId());
 438             break;
 439         case STAT_TYPE_GAMES_SEASON:
 440             stats.games_season = value;
 441             CharacterDatabase.PExecute("UPDATE arena_team_stats SET played = '%u' WHERE arenateamid = '%u'", value, GetId());
 442             break;
 443         case STAT_TYPE_WINS_SEASON:
 444             stats.wins_season = value;
 445             CharacterDatabase.PExecute("UPDATE arena_team_stats SET wins2 = '%u' WHERE arenateamid = '%u'", value, GetId());
 446             break;
 447         case STAT_TYPE_RANK:
 448             stats.rank = value;
 449             CharacterDatabase.PExecute("UPDATE arena_team_stats SET rank = '%u' WHERE arenateamid = '%u'", value, GetId());
 450             break;
 451         default:
 452             sLog.outDebug("unknown stat type in ArenaTeam::SetStats() %u", stat_type);
 453             break;
 454     }
 455 }
 456
 457 uint8 ArenaTeam::GetSlot() const
 458 {
 459     uint8 slot = GetSlotByType(GetType());
 460     if(slot >= MAX_ARENA_SLOT)
 461     {
 462         sLog.outError("Unknown arena team type %u for arena team %u", uint32(GetType()), GetId());
 463         return 0;                                           // better return existed slot to prevent untelated data curruption
 464     }
 465
 466     return slot;
 467 }
 468
 469 void ArenaTeam::BroadcastPacket(WorldPacket *packet)
 470 {
 471     for (MemberList::iterator itr = members.begin(); itr != members.end(); itr++)
 472     {
 473         Player *player = objmgr.GetPlayer(itr->guid);
 474         if(player)
 475             player->GetSession()->SendPacket(packet);
 476     }
 477 }
 478
 479 uint8 ArenaTeam::GetSlotByType( uint32 type )
 480 {
 481     switch(type)
 482     {
 483         case ARENA_TEAM_2v2: return 0;
 484         case ARENA_TEAM_3v3: return 1;
 485         case ARENA_TEAM_5v5: return 2;
 486         default:
 487             break;
 488     }
 489     return 0xFF;
 490 }
 491
 492 bool ArenaTeam::HaveMember( uint64 guid ) const
 493 {
 494     for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 495         if(itr->guid==guid)
 496             return true;
 497
 498     return false;
 499 }
 500
 501 void ArenaTeam::FinishWeek()
 502 {
 503     stats.games_week = 0;                                   // played this week
 504     stats.wins_week = 0;                                    // wins this week
 505     for(MemberList::iterator itr = members.begin(); itr !=  members.end(); ++itr)
 506     {
 507         itr->games_week = 0;
 508         itr->wins_week = 0;
 509     }
 510 }
 511
 512 /*
 513 arenateam fields (id from 2.3.3 client):
 514 1414 - arena team id 2v2
 515 1415 - 0=captain, 1=member
 516 1416 - played this week
 517 1417 - played this season
 518 1418 - unk
 519 1419 - personal arena rating
 520 1420 - arena team id 3v3
 521 1421 - 0=captain, 1=member
 522 1422 - played this week
 523 1423 - played this season
 524 1424 - unk
 525 1425 - personal arena rating
 526 1426 - arena team id 5v5
 527 1427 - 0=captain, 1=member
 528 1428 - played this week
 529 1429 - played this season
 530 1430 - unk
 531 1431 - personal arena rating
 532 */