Que

#include "ScriptPCH.h"

#define TOKENID   123 // obvious


typedef std::set<uint64> playerList;
playerList players;
typedef UNORDERED_MAP<uint64, time_t> cooldownMap;
cooldownMap cooldowns;

class queCommandScript : public CommandScript
{
public:
    queCommandScript() : CommandScript("queCommandScript") { }

    ChatCommand* GetCommands() const
    {
        static ChatCommand QueSubCommandTable[] =
        {
            { "add",            SEC_GAMEMASTER,     true,   &HandleQueAddCommand,       "", NULL },
            { "remove",         SEC_GAMEMASTER,     true,   &HandleQueRemCommand,       "", NULL },
            { "list",           SEC_GAMEMASTER,     true,   &HandleQueListCommand,      "", NULL },
            { "confirm",        SEC_PLAYER,         false,  &HandleQueConfirmCommand,   "", NULL },
            { NULL,             0,                  false,  NULL,                       "", NULL }
        };
        static ChatCommand QueCommandTable[] =
        {
            { "queue",          SEC_PLAYER,         true,   NULL,                       "", QueSubCommandTable },
            { NULL,             0,                  false,  NULL,                       "", NULL }
        };
        return QueCommandTable;
    }

    static bool HandleQueAddCommand(ChatHandler* handler, const char* args)
    {
        if(!args)
            return false;

        Player* target;
        uint64 targetGuid;
        std::string targetName;
        if (!handler->extractPlayerTarget((char*)args, &target, &targetGuid, &targetName))
            return false;

        AddPlayer(targetGuid);
        return true;
    }

    static bool HandleQueRemCommand(ChatHandler* handler, const char* args)
    {
        if(!args)
            return false;

        Player* target;
        uint64 targetGuid;
        std::string targetName;
        if (!handler->extractPlayerTarget((char*)args, &target, &targetGuid, &targetName))
            return false;

        RemovePlayer(targetGuid);
        return true;
    }

    static bool HandleQueListCommand(ChatHandler* handler, const char* args)
    {
        handler->PSendSysMessage("Queued players:");
        const playerList* players = GetPlayers();
        if(players->empty())
            return true;
        playerList::const_iterator it = players->begin();
        uint32 i = 0;
        while(it != players->end() /*&& i < 50*/) // limit list?
        {
            // also prints offline players!
            Player* player = sObjectAccessor->FindPlayer(*it);
            if(player)
                handler->PSendSysMessage("%u. %s %s", ++i, player->GetName().c_str(), player->HasItemCount(TOKENID, 1) ? "is VIP" : "is not VIP");
            ++it;
        }
        return true;
    }

    static bool HandleQueConfirmCommand(ChatHandler* handler, const char* args)
    {
        if(!handler->GetSession())
            return true;
        Player* player = handler->GetSession()->GetPlayer();
        if(!player)
            return true;
        const playerList* players = GetPlayers();
        if(players->empty() || players->find(player->GetGUID()) == players->end())
        {
            handler->PSendSysMessage("You are not in the queue");
            return true;
        }

        bool isVIP = player->HasItemCount(TOKENID, 1);

        cooldownMap* cooldowns = GetCooldowns();
        cooldownMap::const_iterator it = cooldowns->find(player->GetGUID());
        if(it != cooldowns->end() && it->second >= time(NULL))
        {
            handler->PSendSysMessage("Cooldown remaining less than %u hours", uint32((it->second-time(NULL))/HOUR));
            return true;
        }
        if(*players->begin() == player->GetGUID()) // first in que, confirm
            ConfirmPlayer(player);
        else if(isVIP)
        {
            player->DestroyItemCount(TOKENID, 1, true);
            ConfirmPlayer(player);
        }
        else
        {
            uint32 pos = 0;
            playerList::const_iterator it = players->begin();
            while(++it != players->end() && (*it) != player->GetGUID())
                ++pos;
            handler->PSendSysMessage("You are on place %u in the queue", ++pos);
            return true;
        }
        (*cooldowns)[player->GetGUID()] = time(NULL) + (isVIP ? 8*HOUR : 24*HOUR); // 8/24 hour delay
        return true;
    }

    static cooldownMap* GetCooldowns()
    {
        return &cooldowns;
    }
    static playerList* GetPlayers()
    {
        return &players;
    }
    static bool AddPlayer(uint64 guid)
    {
        bool added = players.insert(guid).second;
        if(added && players.size() <= 1)
            SendUpdateMessage();
        return added;
    }
    static void RemovePlayer(uint64 guid)
    {
        if (players.size() >= 2 && *players.begin() == guid)
        {
            players.erase(guid);
            //cooldowns.erase(guid);//dont add incase player can rejoin que
            SendUpdateMessage();
        }
        else
        {
            players.erase(guid);
            //cooldowns.erase(guid);//dont add incase player can rejoin que
        }
    }
    static void SendUpdateMessage()
    {
        if(players.empty())
            return;
        Player* top = sObjectAccessor->FindPlayer(*players.begin());
        if(!top)
        {
            RemovePlayer(*players.begin());
            return;
        }
        const char* name = top->GetName().c_str();
        SessionMap const& smap = sWorld->GetAllSessions();
        for (SessionMap::const_iterator iter = smap.begin(); iter != smap.end(); ++iter)
            if (Player* player = iter->second->GetPlayer())
                if (player->GetSession() && player->IsGameMaster())
                    ChatHandler(iter->second).PSendSysMessage("%s is on top of queue", name);
    }

    static void ConfirmPlayer(Player* player)
    {
        // confirmation code here

        RemovePlayer(player->GetGUID());
    }
};

class queLogOut : PlayerScript
{
public:
    queLogOut() : PlayerScript("queLogOut") { }

    /*
    void OnLogout(Player* player)
    {
    RemovePlayer(player->GetGUID());
    }
    */
    void OnLogin(Player* player)
    {
        queCommandScript::RemovePlayer(player->GetGUID());
    }
};

class queCreatureScript : public CreatureScript
{
public:
    queCreatureScript() : CreatureScript("queCreatureScript") { }

    bool OnGossipHello(Player* player, Creature* creature)
    {
        if(players.find(player->GetGUID()) == players.end())
            player->ADD_GOSSIP_ITEM(0, "Join queue", GOSSIP_SENDER_MAIN, 1);
        else
            player->ADD_GOSSIP_ITEM(0, "Leave queue", GOSSIP_SENDER_MAIN, 2);
        player->ADD_GOSSIP_ITEM(7, "Nevermind..", GOSSIP_SENDER_MAIN, 0);
        player->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, creature->GetGUID());
        return true;
    }

    bool OnGossipSelect(Player* player, Creature* creature, uint32 sender, uint32 action)
    {
        player->PlayerTalkClass->ClearMenus();
        if(sender != GOSSIP_SENDER_MAIN)
            return false;

        switch(action)
        {
        case 1:
            queCommandScript::AddPlayer(player->GetGUID());
            break;
        case 2:
            queCommandScript::RemovePlayer(player->GetGUID());
            break;
        default:
            player->CLOSE_GOSSIP_MENU();
        }
        return true;
    }
};

void AddSC_queSystem()
{
    new queCreatureScript();
    new queCommandScript();
    new queLogOut();
}