Ultimate Duel Script V1.2

#include "scriptPCH.h"
#include "MapManager.h"
#include "Chat.h"
#include "Pet.h"
#include "Config.h"

/* SQL (Only if you use Rating System) (Characters database)
UPDATE `characters` create `duelW` int(10) unsigned NOT NULL DEFAULT '0';
UPDATE `characters` create `duelL` int(10) unsigned NOT NULL DEFAULT '0';
UPDATE `characters` create `duelR` int(10) unsigned NOT NULL DEFAULT '1000';
*/

/* WorldConf (At the end of the file)
# Duel_Reward.Cata_User
#        Default:     0 - (Disabled)
#                     1 - (Enabled)

Duel_Reward.Cata_User = 0

# Duel_Reward.Wotlk_User
#        Default:     0 - (Disabled)
#                     1 - (Enabled)

Duel_Reward.Wotlk_User = 0

# Duel_Reward.Rating
#        Default:     0 - (Disabled)
#                     1 - (Enabled)

Duel_Reward.Rating = 0
*/

/*
Ultimate Duel Script (Reward/Rating/Phasing/Security/Zoned & Reset)
Author : Philippe
Release Date : 14/01/14
Script Complete : 100 %
Version : 3.3.5 & 4.3.4
TrinityCore based.
Tested on 4.3.4 Works Well

Note :
-Reward Part is explain you need to read.
-For the Rating system please use SQL given. You can add a Top for you're website or create a rating npc.

-Phasing system isn't done by me, Credits go to Deathmane1337 (Ac-Web) & Rewrite by Rochet & Tommy (EmuDevs)
Rochet & Tommy (EmuDevs) :
http://emudevs.com/showthread.php/2316-new-phaseing-out-duel-dont-work-100?highlight=duel
http://emudevs.com/showthread.php/2282-phase-out-dueling-error/page2
*/

// Need both to work.
enum Zone_ID
{
    Zone_ID_1 = 1 // Change Zone ID
};

enum Area_ID
{
    Area_ID_1 = 1 // Change Area ID
};

#define Item_Reward_ID 241 // Currency ID For Cata User Or Item ID For Wotlk

#define Token_Winner 3 // Reward Count (Winner)
#define Token_loser 1 // Reward Count (Loser)

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

    // Rating Info Setup Config - Not Tested
    void RatingInfo(Player* player)
    {
        if(sConfigMgr->GetBoolDefault("Duel_Reward.Rating", 1))
        {
            QueryResult result = CharacterDatabase.PQuery("SELECT duelR FROM characters WHERE guid = '%u'", player->GetGUID());
            if(!result)
                return;

            Field * fields = NULL;
            do
            {
                fields = result->Fetch();
                uint32 duelR = fields[0].GetUInt32();
                char msg[250];
                snprintf(msg, 250, "|cffff6060[Rating] : |cffFFFF00%u \n", duelR);
                ChatHandler(player->GetSession()).PSendSysMessage(msg);
            }
            while(result->NextRow());
        }
    }

    void RevivePlayer(Player* player)
    {
        player->SetHealth(player->GetMaxHealth());
        if(player->getPowerType() == POWER_MANA)
            player->SetPower(POWER_MANA, player->GetMaxPower(POWER_MANA));
        if(player->getPowerType() == POWER_ENERGY)
            player->SetPower(POWER_ENERGY, player->GetMaxPower(POWER_ENERGY));
    }

    void OnDuelStart(Player *player, Player *plTarget)
    {
        // Duel Start Reset (Hp/Mana etc)
        RevivePlayer(player);
        RevivePlayer(plTarget);
        player->SetPower(POWER_RAGE, 0);
        plTarget->SetPower(POWER_RAGE, 0);
        player->SetPower(POWER_RUNIC_POWER, 0);
        plTarget->SetPower(POWER_RUNIC_POWER, 0);

        if(sConfigMgr->GetBoolDefault("Duel_Reward.Rating", 1))
        {
            // Rating checkup // Not Tested
            RatingInfo(player);
            RatingInfo(plTarget);
        }
    }

    void OnDuelEnd(Player *player, Player * plTarget,  DuelCompleteType type)
    {
        //Removing all Cooldown
        player->RemoveAllSpellCooldown();
        plTarget->RemoveAllSpellCooldown();
        // Duel Reset (Hp/Mana etc)
        RevivePlayer(player);
        RevivePlayer(plTarget);
        // Stopping Combat (Auto Hit/Cast/Range Auto Hit) Break (Useful)
        player->CombatStop();
        plTarget->CombatStop();

        player->InterruptSpell(CURRENT_AUTOREPEAT_SPELL); // break Auto Shot and auto hit
        plTarget->InterruptSpell(CURRENT_CHANNELED_SPELL);  // break channelled spells

        player->AttackStop();
        plTarget->AttackStop();
    }

};

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

    void OnDuelEnd(Player *winner, Player *looser, DuelCompleteType type)
    {
        //Zone & Area Check Please change value in enum.
        if ((winner->GetZoneId() == Zone_ID_1 && looser->GetZoneId() == Zone_ID_1 || winner->GetAreaId() == Area_ID_1 &&  looser->GetAreaId() == Area_ID_1) && type == DUEL_WON)
        {
            // Level Check if player is not MaxLevel (80+)
            if (winner->getLevel() >= 1 && looser->getLevel() <= 79 && (type == DUEL_WON || type == DUEL_INTERRUPTED || type == DUEL_FLED))
            {
                return;
            }
            // Check Latency of both (Not Really needed)
            if (looser->GetSession()->GetLatency() > 350 && (type == DUEL_WON || type == DUEL_INTERRUPTED || type == DUEL_FLED))
            {
                ChatHandler(winner->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF  !! ALERT !! One of you has a latency superior to 350");
                ChatHandler(looser->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF  !! ALERT !! One of you has a latency superior to 350");
                return;
            }
            // Used if player didn't reach less than 10 life.
            if (looser->GetHealth() > 10)
            {
                ChatHandler(looser->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF No one killed the other !");
                ChatHandler(winner->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF No one killed the other !");
                return;
            }
            // Used For Test Versus GM
            if (looser->GetSession()->GetSecurity() >= 2 && (type == DUEL_WON || type == DUEL_INTERRUPTED || type == DUEL_FLED))
            {
                ChatHandler(winner->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF You Can't Claim Reward When you're vs a GameMaster !");
                ChatHandler(looser->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF You Can't Claim Reward When you're vs a GameMaster !" );
                return;
            }
            if (winner->GetSession()->GetSecurity() >= 2 && (type == DUEL_WON || type == DUEL_INTERRUPTED || type == DUEL_FLED))
            {
                ChatHandler(winner->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF You Can't Claim Reward When you're vs a GameMaster !");
                ChatHandler(looser->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF You Can't Claim Reward When you're vs a GameMaster !");
                return;
            }
            // Used for Cata user if player dosen't have enough gear equipped based on (Stamina/life)
            // *Could be adapted for Wotlk Users.
            if (looser->GetStat(STAT_STAMINA) < 4000 && type == DUEL_WON)
            {
                ChatHandler(winner->GetSession()).PSendSysMessage("|cFFFFFC00[Cheating System]|cFF00FFFF The player you are fighting dosen't have enough gear equipped !");
                ChatHandler(looser->GetSession()).PSendSysMessage("|cFFFFFC00[Cheating System]|cFF00FFFF you don't have enough gear equipped  !");
                return;
            }
            // Used for Local Connections, same IP
            if (winner->GetSession()->GetRemoteAddress() == looser->GetSession()->GetRemoteAddress())
            {
                ChatHandler(winner->GetSession()).SendGlobalGMSysMessage("|cFFFFFC00[Cheating System]|cFF00FFFF A player is trying to cheat in duel Area !");
                ChatHandler(winner->GetSession()).PSendSysMessage("|cFFFFFC00[Cheating System]|cFF00FFFF you can't claim reward vs a same ip !");
                ChatHandler(looser->GetSession()).PSendSysMessage("|cFFFFFC00[Cheating System]|cFF00FFFF you can't claim reward vs a same ip !");
            }
            //If everything is passed then reward will be.
            else
            {
                //To make it work please make sure the worldserver.conf is correctly configurate
                /*--------------Cataclysm Users------------*/
                if(sConfigMgr->GetBoolDefault("Duel_Reward.Cata_User", 1))
                {
                    winner->ModifyCurrency(Item_Reward_ID, Token_Winner, true,true);
                    looser->ModifyCurrency(Item_Reward_ID, Token_loser, true,true);
                }
                /*----------------Wotlk Users---------------*/
                if(sConfigMgr->GetBoolDefault("Duel_Reward.Wotlk_User", 1))
                {
                    winner->AddItem(Item_Reward_ID, Token_Winner);
                    looser->AddItem(Item_Reward_ID, Token_loser);
                }
                winner->SaveToDB();
                looser->SaveToDB();
                /*
                /*Duel Rating*/
                //Duel Ratio, Win/lose
                if(sConfigMgr->GetBoolDefault("Duel_Reward.Rating", 1))
                {
                    CharacterDatabase.PExecute("UPDATE characters SET duelW = (duelW+1) WHERE guid = '%u'", winner->GetGUID());
                    CharacterDatabase.PExecute("UPDATE characters SET duelL = (duelL+1) WHERE guid = '%u'", looser->GetGUID());
                    //Duel Rating, Win/lose (Change Points Manually)
                    CharacterDatabase.PExecute("UPDATE characters SET duelR = (duelR+14) WHERE guid = '%u'", winner->GetGUID());
                    CharacterDatabase.PExecute("UPDATE characters SET duelR = (duelR-7) WHERE guid = '%u'", looser->GetGUID());
                    //Duel Announcement, Win/lose (Change Points Manually.
                    ChatHandler(winner->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF Well done you won 14 Points !");
                    ChatHandler(looser->GetSession()).PSendSysMessage("|cFFFFFC00[System]|cFF00FFFF Ow you lose 7 Points !");
                }
            }
        }
    }
};

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

    void OnDuelStart(Player* firstplayer, Player* secondplayer)
    {
        Map* map = firstplayer->GetMap();
        uint32 usedPhases = 0; // used phases
        Map::PlayerList const& players = map->GetPlayers();
        for (Map::PlayerList::const_iterator iter = players.begin(); iter != players.end(); ++iter)
        {
            Player* check = iter->GetSource();
            if (!check || !check->GetSession())
                continue;
            usedPhases |= check->GetPhaseMask(); // insert player's phases to used phases
        }

        for (uint32 phase = 2; phase <= ULONG_MAX/2; phase *= 2) // loop all unique phases
        {
            if (usedPhases & phase) // If phase in use
                continue;

            firstplayer->SetPhaseMask(phase, true);
            secondplayer->SetPhaseMask(phase, true);
            if (GameObject* go = map->GetGameObject(firstplayer->GetUInt64Value(PLAYER_DUEL_ARBITER)))
                go->SetPhaseMask(phase, true);

            return;
        }
        // Could not phase players :(
    }

    // Restore phases
    void OnDuelEnd(Player* firstplayer, Player* secondplayer, DuelCompleteType type)
    {
        firstplayer->SetPhaseMask(GetPhase(firstplayer), true);
        if (Pet* pet = firstplayer->GetPet())
            pet->SetPhaseMask(GetPhase(firstplayer), true);
        secondplayer->SetPhaseMask(GetPhase(secondplayer), true);
        if (Pet* pet = secondplayer->GetPet())
            pet->SetPhaseMask(GetPhase(secondplayer), true);
    }

    // Attempt in storing the player phase with spell phases included.
    uint32 GetPhase(Player* player) const
    {
        if (player->IsGameMaster())
            return uint32(PHASEMASK_ANYWHERE);

        // GetPhaseMaskForSpawn copypaste
        uint32 phase = PHASEMASK_NORMAL;
        Player::AuraEffectList const& phases = player->GetAuraEffectsByType(SPELL_AURA_PHASE);
        if (!phases.empty())
            phase = phases.front()->GetMiscValue();
        if (uint32 n_phase = phase & ~PHASEMASK_NORMAL)
            return n_phase;

        return PHASEMASK_NORMAL;
    }
};

void AddSC_Reset()
{
    new Duel_Token_Reward();
    new Duel_Reset();
    new PhasedDueling();
}