mirror of
https://github.com/ornfelt/azerothcore_lua_scripts
synced 2026-08-22 06:26:03 -04:00
713 lines
25 KiB
C++
713 lines
25 KiB
C++
/*
|
|
* Copyright (C) 2008-2012 TrinityCore <http://www.trinitycore.org/>
|
|
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "Arena.h"
|
|
#include "BattlegroundMgr.h"
|
|
#include "Bracket.h"
|
|
#include "Group.h"
|
|
#include "SpectatorAddon.h"
|
|
#include "ScriptMgr.h"
|
|
#include "Chat.h"
|
|
#include "ScriptedGossip.h"
|
|
|
|
class arena_spectator_commands : public CommandScript
|
|
{
|
|
public:
|
|
arena_spectator_commands() : CommandScript("arena_spectator_commands") { }
|
|
|
|
static bool HandleSpectateCommand(ChatHandler* handler, const char* args)
|
|
{
|
|
Player* player = nullptr;
|
|
auto name = handler->extractPlayerNameFromLink((char*)args);
|
|
if (!name.empty())
|
|
player = sObjectAccessor->FindPlayerByName(name.c_str());
|
|
else
|
|
player = handler->getSelectedPlayer();
|
|
|
|
if (!player)
|
|
{
|
|
handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
|
|
return false;
|
|
}
|
|
|
|
return SpectateByGuid(handler, player->GetGUID());
|
|
}
|
|
|
|
static bool SpectateByGuid(ChatHandler* handler, ObjectGuid guid)
|
|
{
|
|
auto targetGuid = guid;
|
|
auto player = handler->GetSession()->GetPlayer();
|
|
|
|
if (targetGuid == player->GetGUID())
|
|
{
|
|
handler->SendSysMessage(LANG_CANT_TELEPORT_SELF);
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (player->isInCombat())
|
|
{
|
|
handler->SendSysMessage(LANG_YOU_IN_COMBAT);
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (!player->isAlive())
|
|
{
|
|
handler->SendSysMessage("You are dead.");
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (player->GetPet())
|
|
{
|
|
handler->PSendSysMessage("You must hide your pet.");
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (auto tPlayer = ObjectAccessor::FindPlayer(targetGuid))
|
|
{
|
|
if (tPlayer && player && !player->GetMap()->IsBattlegroundOrArena())
|
|
{
|
|
Battleground* bg = tPlayer->GetBattleground();
|
|
if (!bg || bg->GetStatus() != STATUS_IN_PROGRESS)
|
|
{
|
|
handler->PSendSysMessage("Battleground has not started.");
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
player->SetBattlegroundId(tPlayer->GetBattlegroundId(), tPlayer->GetBattlegroundTypeId());
|
|
player->SetBattlegroundEntryPoint();
|
|
|
|
if (player->TeleportTo(tPlayer->GetMapId(), tPlayer->GetPositionX(), tPlayer->GetPositionY(), tPlayer->GetPositionZ(), 0.0f))
|
|
{
|
|
player->SetSpectate(true);
|
|
if (player->GetBattleground())
|
|
player->GetBattleground()->AddSpectator(player);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool HandleSpectateCancelCommand(ChatHandler* handler, const char* /*args*/)
|
|
{
|
|
auto player = handler->GetSession()->GetPlayer();
|
|
if (!player->IsSpectator())
|
|
{
|
|
handler->PSendSysMessage("You are not spectator.");
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (!player->GetBattleground())
|
|
{
|
|
handler->PSendSysMessage("You are not spectator.");
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
//player->GetBattleground()->RemoveSpectator(player);
|
|
//player->CancelSpectate();
|
|
player->TeleportToBGEntryPoint();
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool HandleSpectateFromCommand(ChatHandler* handler, const char *args)
|
|
{
|
|
Player* target;
|
|
ObjectGuid target_guid;
|
|
std::string target_name;
|
|
if (!handler->extractPlayerTarget((char*)args, &target, &target_guid, &target_name))
|
|
return false;
|
|
|
|
auto player = handler->GetSession()->GetPlayer();
|
|
if (!target || target->isGameMaster())
|
|
{
|
|
handler->PSendSysMessage("Cant find player.");
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (!player->IsSpectator())
|
|
{
|
|
//handler->PSendSysMessage(LANG_SPECTATOR_NOT_SPECTATOR);
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (target->IsSpectator() && target != player)
|
|
{
|
|
handler->PSendSysMessage("Can`t do that. Your target is spectator.");
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (player->GetMap() != target->GetMap())
|
|
{
|
|
handler->PSendSysMessage("Cant do that. Different arenas?");
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
auto bGround = target->GetBattleground();
|
|
if (!bGround)
|
|
return false;
|
|
|
|
if (target->HasAura(32728) || target->HasAura(32727))
|
|
{
|
|
//handler->PSendSysMessage(LANG_SPECTATOR_BG_NOT_STARTED);
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (target->HasAuraType(SPELL_AURA_MOD_STEALTH) || target->HasAuraType(SPELL_AURA_MOD_INVISIBILITY))
|
|
{
|
|
//handler->PSendSysMessage(LANG_SPECTATOR_CANNT_SEE);
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
target == player && player->GetSpectateFrom() ? player->SetViewpoint(player->GetSpectateFrom(), false) : player->SetViewpoint(target, true);
|
|
return true;
|
|
}
|
|
|
|
static bool HandleSpectateResetCommand(ChatHandler* handler, const char* /*args*/)
|
|
{
|
|
auto player = handler->GetSession()->GetPlayer();
|
|
if (!player)
|
|
{
|
|
handler->PSendSysMessage("Cant find player.");
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
if (!player->IsSpectator())
|
|
{
|
|
//handler->PSendSysMessage(LANG_SPECTATOR_NOT_SPECTATOR);
|
|
handler->SetSentErrorMessage(true);
|
|
return false;
|
|
}
|
|
|
|
auto bGround = player->GetBattleground();
|
|
if (!bGround)
|
|
return false;
|
|
|
|
if (bGround->GetStatus() != STATUS_IN_PROGRESS)
|
|
return true;
|
|
|
|
for (auto itr : bGround->GetBattlegroundScoreMap())
|
|
if (auto tmpPlayer = ObjectAccessor::FindPlayer(itr.first))
|
|
{
|
|
auto tmpID = bGround->GetPlayerTeam(tmpPlayer->GetGUID());
|
|
auto pGuid = tmpPlayer->GetGUID();
|
|
auto pName = tmpPlayer->GetName();
|
|
ObjectGuid tGuid;
|
|
|
|
if (auto target = tmpPlayer->GetSelectedPlayer())
|
|
tGuid = target->GetGUID();
|
|
|
|
SpectatorAddonMsg msg;
|
|
msg.SetPlayer(pGuid);
|
|
msg.SetName(pName);
|
|
if (tGuid)
|
|
msg.SetTarget(tGuid);
|
|
if (Pet* pPet = tmpPlayer->GetPet())
|
|
{
|
|
msg.SetPet(pPet->GetCreatureTemplate()->Family);
|
|
msg.SetPetHP(pPet->GetHealthPct());
|
|
}
|
|
else
|
|
{
|
|
msg.SetPet(0);
|
|
msg.SetPetHP(0);
|
|
}
|
|
msg.SetStatus(tmpPlayer->isAlive());
|
|
msg.SetClass(tmpPlayer->getClass());
|
|
msg.SetCurrentHP(tmpPlayer->GetHealth());
|
|
msg.SetMaxHP(tmpPlayer->GetMaxHealth());
|
|
auto powerType = tmpPlayer->getPowerType();
|
|
msg.SetMaxPower(tmpPlayer->GetMaxPower(powerType));
|
|
msg.SetCurrentPower(tmpPlayer->GetPower(powerType));
|
|
msg.SetPowerType(powerType);
|
|
msg.SetTeam(tmpID);
|
|
msg.SetEndTime(int32(time(nullptr) + std::chrono::duration_cast<Seconds>(Minutes(25) - bGround->GetElapsedTime()).count()));
|
|
msg.SendPacket(player->GetGUID());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
ChatCommand* GetCommands() const override
|
|
{
|
|
static ChatCommand spectateCommandTable[] =
|
|
{
|
|
{ "player", SEC_PLAYER, true, &HandleSpectateCommand, "", nullptr },
|
|
{ "view", SEC_PLAYER, true, &HandleSpectateFromCommand, "", nullptr },
|
|
{ "reset", SEC_PLAYER, true, &HandleSpectateResetCommand, "", nullptr },
|
|
{ "leave", SEC_PLAYER, true, &HandleSpectateCancelCommand, "", nullptr },
|
|
{ nullptr, SEC_PLAYER, false, nullptr, "", nullptr }
|
|
};
|
|
|
|
static ChatCommand commandTable[] =
|
|
{
|
|
{ "spectate", SEC_PLAYER, false, nullptr, "", spectateCommandTable },
|
|
{ nullptr, SEC_PLAYER, false, nullptr, "", nullptr }
|
|
};
|
|
return commandTable;
|
|
}
|
|
};
|
|
|
|
|
|
enum NpcSpectatorAtions
|
|
{
|
|
NPC_SPECTATOR_REFRESH_LOW = 1,
|
|
NPC_SPECTATOR_REFRESH_HIGH = 2,
|
|
NPC_SPECTATOR_REFRESH_RBG = 3,
|
|
NPC_SPECTATOR_ACTION_LIST_ARENA = 1000,
|
|
NPC_SPECTATOR_ACTION_LIST_RATED_BG = 2000,
|
|
NPC_SPECTATOR_ACTION_LIST_LOW_GAMES = 3000,
|
|
NPC_SPECTATOR_ACTION_LIST_TOP_GAMES = 4000,
|
|
NPC_SPECTATOR_ACTION_SELECTED_PLAYER = 5000
|
|
};
|
|
|
|
static uint16 const TopGamesRating = 1800;
|
|
static uint8 const GamesOnPage = 20;
|
|
|
|
class npc_arena_spectator : public CreatureScript
|
|
{
|
|
public:
|
|
npc_arena_spectator() : CreatureScript("npc_arena_spectator") { }
|
|
|
|
bool OnGossipHello(Player* player, Creature* creature) override
|
|
{
|
|
if (player->InBattlegroundQueue())
|
|
{
|
|
creature->MonsterWhisper("You should leave the queue!", player->GetGUID(), true);
|
|
return false;
|
|
}
|
|
|
|
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "Arena", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_LIST_ARENA);
|
|
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "Rated Battleground", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_LIST_RATED_BG);
|
|
player->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, creature->GetGUID());
|
|
return true;
|
|
}
|
|
|
|
bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) override
|
|
{
|
|
player->PlayerTalkClass->ClearMenus();
|
|
|
|
if (action == NPC_SPECTATOR_ACTION_LIST_ARENA)
|
|
{
|
|
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "View games with high rating...", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_LIST_TOP_GAMES);
|
|
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "View games with low rating...", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_LIST_LOW_GAMES);
|
|
player->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, creature->GetGUID());
|
|
}
|
|
else if (action == NPC_SPECTATOR_REFRESH_RBG || action == NPC_SPECTATOR_ACTION_LIST_RATED_BG)
|
|
{
|
|
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "Refresh", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_REFRESH_RBG);
|
|
ShowRBGPage(player, action == NPC_SPECTATOR_REFRESH_RBG ? 0 : action - NPC_SPECTATOR_ACTION_LIST_RATED_BG);
|
|
player->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, creature->GetGUID());
|
|
}
|
|
else if (action == NPC_SPECTATOR_REFRESH_LOW || action >= NPC_SPECTATOR_ACTION_LIST_LOW_GAMES && action < NPC_SPECTATOR_ACTION_LIST_TOP_GAMES)
|
|
{
|
|
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "Refresh", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_REFRESH_LOW);
|
|
ShowPage(player, action == NPC_SPECTATOR_REFRESH_LOW ? 0 : action - NPC_SPECTATOR_ACTION_LIST_LOW_GAMES, false);
|
|
player->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, creature->GetGUID());
|
|
}
|
|
else if (action == NPC_SPECTATOR_REFRESH_HIGH || action >= NPC_SPECTATOR_ACTION_LIST_TOP_GAMES && action < NPC_SPECTATOR_ACTION_SELECTED_PLAYER)
|
|
{
|
|
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "Refresh", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_REFRESH_HIGH);
|
|
ShowPage(player, action == NPC_SPECTATOR_REFRESH_HIGH ? 0 : action - NPC_SPECTATOR_ACTION_LIST_TOP_GAMES, true);
|
|
player->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, creature->GetGUID());
|
|
}
|
|
else
|
|
{
|
|
ChatHandler handler(player);
|
|
arena_spectator_commands::SpectateByGuid(&handler, ObjectGuid::Create<HighGuid::Player>(action - NPC_SPECTATOR_ACTION_SELECTED_PLAYER));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::string GetGamesStringData(Battleground* bg, uint16 team)
|
|
{
|
|
std::string teamsMember[MAX_TEAMS];
|
|
uint16 firstTeamMMR = 0;
|
|
uint16 secondTeamMMR = 0;
|
|
|
|
for (auto itr = bg->GetPlayers().begin(); itr != bg->GetPlayers().end(); ++itr)
|
|
{
|
|
if (auto player = ObjectAccessor::FindPlayer(itr->first))
|
|
{
|
|
if (player->IsSpectator())
|
|
continue;
|
|
|
|
uint8 bracketType = MS::Battlegrounds::GetBracketByJoinType(bg->GetJoinType());
|
|
|
|
auto* grp = player->GetGroup();
|
|
if (!grp || grp->GetLeaderGUID() != player->GetGUID())
|
|
continue;
|
|
|
|
if (player->GetBGTeam() == team)
|
|
firstTeamMMR = grp->GetAverageMMR(bracketType);
|
|
else
|
|
secondTeamMMR = grp->GetAverageMMR(bracketType);
|
|
|
|
teamsMember[team != player->GetBGTeam()] += GetSpecClassNameById(player->getClass(), player->GetSpecializationId());
|
|
}
|
|
}
|
|
|
|
std::stringstream data;
|
|
data << teamsMember[0] << "[" << firstTeamMMR << "] - " << teamsMember[1] << "[" << secondTeamMMR << "]";
|
|
return data.str();
|
|
}
|
|
|
|
Player* GetFirstPlayer(Battleground* arena)
|
|
{
|
|
for (auto itr = arena->GetPlayers().begin(); itr != arena->GetPlayers().end(); ++itr)
|
|
if (auto player = ObjectAccessor::FindPlayer(itr->first))
|
|
return player;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void ShowPage(Player* gPlayer, uint16 page, bool isTop)
|
|
{
|
|
uint16 highGames = 0;
|
|
uint16 lowGames = 0;
|
|
bool haveNextPage = false;
|
|
|
|
auto sdataStore = sBattlegroundMgr->GetSpectatorData();
|
|
for (auto &kv : sdataStore)
|
|
{
|
|
std::string data;
|
|
uint8 PtLeaderCount = 0;
|
|
uint8 type = 2;
|
|
uint16 team = 0;
|
|
uint32 lowGuid = 0;
|
|
Battleground* bg = nullptr;
|
|
|
|
for (std::list<ObjectGuid>::const_iterator itr = kv.second.begin(); itr != kv.second.end(); ++itr)
|
|
{
|
|
ObjectGuid guid = *itr;
|
|
auto player = ObjectAccessor::FindPlayer(guid);
|
|
if (!player)
|
|
continue;
|
|
|
|
if (!bg)
|
|
bg = player->GetBattleground();
|
|
|
|
if (!bg || !bg->IsArena() || !bg->IsRated())
|
|
continue;
|
|
|
|
auto bracket = player->getBracket(MS::Battlegrounds::GetBracketByJoinType(bg->GetJoinType()));
|
|
if (!bracket)
|
|
continue;
|
|
|
|
if (bracket->getMMV() > TopGamesRating)
|
|
type = 1;
|
|
|
|
team = player->GetBGTeam();
|
|
lowGuid = guid.GetGUIDLow();
|
|
PtLeaderCount++;
|
|
}
|
|
|
|
if (PtLeaderCount != 2)
|
|
continue;
|
|
|
|
data += GetGamesStringData(bg, team);
|
|
|
|
if (isTop && type == 1/*'H'*/)
|
|
{
|
|
highGames++;
|
|
if (highGames > (page + 1) * GamesOnPage)
|
|
{
|
|
haveNextPage = true;
|
|
break;
|
|
}
|
|
|
|
if (highGames >= page * GamesOnPage)
|
|
gPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE, data, GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_SELECTED_PLAYER + lowGuid);
|
|
}
|
|
else if (!isTop && type == 2/*'L'*/)
|
|
{
|
|
lowGames++;
|
|
if (lowGames > (page + 1) * GamesOnPage)
|
|
{
|
|
haveNextPage = true;
|
|
break;
|
|
}
|
|
|
|
if (lowGames >= page * GamesOnPage)
|
|
gPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE, data, GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_SELECTED_PLAYER + lowGuid);
|
|
}
|
|
}
|
|
|
|
if (page > 0)
|
|
gPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, "Prev...", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_LIST_LOW_GAMES + page - 1);
|
|
|
|
if (haveNextPage)
|
|
gPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, "Next...", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_LIST_LOW_GAMES + page + 1);
|
|
}
|
|
|
|
void ShowRBGPage(Player* gPlayer, uint16 page)
|
|
{
|
|
uint16 games = 0;
|
|
bool haveNextPage = false;
|
|
|
|
auto sdataStore = sBattlegroundMgr->GetSpectatorData();
|
|
for (auto &kv : sdataStore)
|
|
{
|
|
std::string data;
|
|
uint8 PtLeaderCount = 0;
|
|
uint16 team = 0;
|
|
uint32 lowGuid = 0;
|
|
Battleground* bg = nullptr;
|
|
|
|
for (std::list<ObjectGuid>::const_iterator itr = kv.second.begin(); itr != kv.second.end(); ++itr)
|
|
{
|
|
ObjectGuid guid = *itr;
|
|
auto player = ObjectAccessor::FindPlayer(guid);
|
|
if (!player)
|
|
continue;
|
|
|
|
if (!bg)
|
|
bg = player->GetBattleground();
|
|
|
|
if (!bg || !bg->IsRBG())
|
|
continue;
|
|
|
|
auto bracket = player->getBracket(MS::Battlegrounds::GetBracketByJoinType(bg->GetJoinType()));
|
|
if (!bracket)
|
|
continue;
|
|
|
|
team = player->GetBGTeam();
|
|
lowGuid = guid.GetGUIDLow();
|
|
PtLeaderCount++;
|
|
}
|
|
|
|
if (PtLeaderCount != 2)
|
|
continue;
|
|
|
|
data += GetGamesStringData(bg, team);
|
|
|
|
games++;
|
|
if (games > (page + 1) * GamesOnPage)
|
|
{
|
|
haveNextPage = true;
|
|
break;
|
|
}
|
|
|
|
if (games >= page * GamesOnPage)
|
|
gPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE, data, GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_SELECTED_PLAYER + lowGuid);
|
|
}
|
|
|
|
if (page > 0)
|
|
gPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, "Prev...", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_LIST_RATED_BG + page - 1);
|
|
|
|
if (haveNextPage)
|
|
gPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, "Next...", GOSSIP_SENDER_MAIN, NPC_SPECTATOR_ACTION_LIST_RATED_BG + page + 1);
|
|
}
|
|
|
|
std::string GetSpecClassNameById(uint8 Id, uint32 Spec)
|
|
{
|
|
std::string sClass = "";
|
|
switch (Id)
|
|
{
|
|
case CLASS_WARRIOR:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_WARRIOR_ARMS:
|
|
sClass = "AWarrior ";
|
|
break;
|
|
case SPEC_WARRIOR_FURY:
|
|
sClass = "FWarrior ";
|
|
break;
|
|
case SPEC_WARRIOR_PROTECTION:
|
|
sClass = "PWarrior ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_PALADIN:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_PALADIN_HOLY:
|
|
sClass = "HPala ";
|
|
break;
|
|
case SPEC_PALADIN_PROTECTION:
|
|
sClass = "PPala ";
|
|
break;
|
|
case SPEC_PALADIN_RETRIBUTION:
|
|
sClass = "RPala ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_HUNTER:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_HUNTER_BEASTMASTER:
|
|
sClass = "BHunt ";
|
|
break;
|
|
case SPEC_HUNTER_MARKSMAN:
|
|
sClass = "MHunt ";
|
|
break;
|
|
case SPEC_HUNTER_SURVIVAL:
|
|
sClass = "SHunt ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_ROGUE:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_ROGUE_ASSASSINATION:
|
|
sClass = "ARogue ";
|
|
break;
|
|
case SPEC_ROGUE_COMBAT:
|
|
sClass = "CRogue ";
|
|
break;
|
|
case SPEC_ROGUE_SUBTLETY:
|
|
sClass = "SRogue ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_PRIEST:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_PRIEST_DISCIPLINE:
|
|
sClass = "DPriest ";
|
|
break;
|
|
case SPEC_PRIEST_HOLY:
|
|
sClass = "HPriest ";
|
|
break;
|
|
case SPEC_PRIEST_SHADOW:
|
|
sClass = "SPriest ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_DEATH_KNIGHT:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_DK_BLOOD:
|
|
sClass = "BDk ";
|
|
break;
|
|
case SPEC_DK_FROST:
|
|
sClass = "FDk ";
|
|
break;
|
|
case SPEC_DK_UNHOLY:
|
|
sClass = "UDk ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_SHAMAN:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_SHAMAN_ELEMENTAL:
|
|
sClass = "ELShaman ";
|
|
break;
|
|
case SPEC_SHAMAN_ENHANCEMENT:
|
|
sClass = "ENShaman ";
|
|
break;
|
|
case SPEC_SHAMAN_RESTORATION:
|
|
sClass = "RShaman ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_MAGE:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_MAGE_ARCANE:
|
|
sClass = "AMage ";
|
|
break;
|
|
case SPEC_MAGE_FIRE:
|
|
sClass = "FIMage ";
|
|
break;
|
|
case SPEC_MAGE_FROST:
|
|
sClass = "FRMage ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_WARLOCK:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_WARLOCK_AFFLICTION:
|
|
sClass = "ALock ";
|
|
break;
|
|
case SPEC_WARLOCK_DEMONOLOGY:
|
|
sClass = "DemoLock ";
|
|
break;
|
|
case SPEC_WARLOCK_DESTRUCTION:
|
|
sClass = "DestLock ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_DRUID:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_DRUID_BALANCE:
|
|
sClass = "BDruid ";
|
|
break;
|
|
case SPEC_DRUID_CAT:
|
|
sClass = "FDruid ";
|
|
break;
|
|
case SPEC_DRUID_BEAR:
|
|
sClass = "FDruid ";
|
|
break;
|
|
case SPEC_DRUID_RESTORATION:
|
|
sClass = "RDruid ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_MONK:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_MONK_BREWMASTER:
|
|
sClass = "BmMonk ";
|
|
break;
|
|
case SPEC_MONK_WINDWALKER:
|
|
sClass = "WwMonk ";
|
|
break;
|
|
case SPEC_MONK_MISTWEAVER:
|
|
sClass = "MwMonk ";
|
|
break;
|
|
}
|
|
break;
|
|
case CLASS_DEMON_HUNTER:
|
|
switch (Spec)
|
|
{
|
|
case SPEC_DEMON_HUNER_HAVOC:
|
|
sClass = "HavocDH ";
|
|
break;
|
|
case SPEC_DEMON_HUNER_VENGEANCE:
|
|
sClass = "VengDH ";
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return sClass;
|
|
}
|
|
};
|
|
|
|
void AddSC_arena_spectator_script()
|
|
{
|
|
new arena_spectator_commands();
|
|
new npc_arena_spectator();
|
|
}
|