Matenia

Gotta delete the warlock settings for that character in your settings folder

wRobot will always buy the drink you manually select in the drink tab, but unless you set up vendors and re-buying correctly in the settings, it won't go to vendors specifically.
Instead, it will just happen to fill up to the amount you set in the Buy/Sell settings, if you have the vendor window open and the vendor sells that item. 

There's a setting which allows you to buy lower level drinks. You can't choose this yourself, the levels are hard coded. But generally speaking, it will not buy drinks that are absolute max level by default, these are the level ranges (levels are basically -5 if you choose highest level drinks in the settings).

{ 0, 159 }, // Refreshing Spring water
{ 5, 159 }, // Refreshing Spring water
{ 10, 1179 }, // Ice Cold Milk
{ 20, 1205 }, // Melon Juice
{ 30, 1708 }, // Sweet Nectar
{ 40, 1645 }, // Moonberry Juice
{ 50, 8766 }, // Morning Glory Dew

https://wrobot.eu/search/?q=facing

adjust your regen settings, they have nothing to do with the fightclass
If you don't set up food, you'll have to at least set percentages that are reasonable, or wRobot will just regen by waiting.

In all fairness, Droidz has been adding a shit ton of these features to the bot base by now. It's just that nobody bothers to learn how to set them up at all. 
You can absolutely make your bot go to vendor to buy ammo/food/drink/etc without ever having to know a single line of C# code.

All of these features are now more or less in wRobot, if you set them up as well:
 

Quote

• spirit rezz if chain dying
• ignore all combat if items are broken
• stop combat with evading mobs, friendly NPCs and friendly pets
• hearthstone if stuck (please read instructions)
• stop combat with tapped targets
• stop combat if target is evading
• advanced (combat) looter to never miss loot/skinning again

Since it's not a buff in vanilla, no.

Yep, that's the Lua to move bug. Make sure your profile doesn't deactive it and make sure you're not using any conflicting plugins like SmoothMove (my edit should work).

By crash do you mean the client freezes with deadlock? This could be cause by your profile or a plugin deactivating Use Lua to move.
Otherwise I doubt it's my fightclass causing crashes. You can try deactivating frame lock in the fightclass settings though

No, this is really only for BGs

using robotManager.Helpful;
using robotManager.Products;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using wManager.Plugin;
using wManager.Events;
using wManager.Wow.Bot.Tasks;
using wManager.Wow.Enums;
using wManager.Wow.Helpers;
using wManager.Wow.ObjectManager;
using System.ComponentModel;
using System.Threading.Tasks;
using System.Configuration;
using wManager.Wow.Class;


public class Main : IPlugin
{
    private string version = "1.6.1";
    public static int timer = 0;
    public static bool _isLaunched;
    private static float saveDistance;
    public static Vector3 destinationVector = new Vector3(0, 0, 0);
    public static bool inProcessing = false;
    public static bool _takenTaxi = false;
    static FlightMasterDB from = (FlightMasterDB)null;
    static FlightMasterDB to = (FlightMasterDB)null;
    static FlightMasterDB discoverTaxiNode = (FlightMasterDB)null;
    public static bool _timer = false;
    public static bool _discoverTaxiTimer = false;
    public static bool changer = true;
    public static bool _updateNodes;
    public static bool checkPath = true;
    public static bool checkPathActive = false;
    public static FlightMasterDB checkPathActiveFM = (FlightMasterDB)null;
    public static bool cancelCheckPathThread = false;
    public static bool pauseCheckPathThread = false;
    public static string status = "";
    public static string statusDiscover = "";
    public static bool _copySettings { get; set; }
    public static bool _runScan = false;
    public static FlightMasterDB taxiToDiscover = (FlightMasterDB)null;
    public static bool _taxiToDiscover = false;
    public static bool _discoverInProessing = false;
    public static int stuckCounter = 0;

    //public static bool followingPath = false;
    //public static bool firstStart;
    //public static bool _logPause = false;
    //public static bool abortFlight = false;
    //public static bool _disposeInstance = false;
    //public static bool cancleOldMovement = false;
    //public static bool paused = false;
    //public static Vector3 myPositionAtStart = new Vector3(0, 0, 0);
    //public bool _deleteOldPath = false;

    public void Initialize()
    {
        Logging.Write("[VanillaFlightMaster]: Flight Master initialized - " + version);
        _isLaunched = true;
        inProcessing = false;
        _copySettings = true;
        _runScan = true;
        _updateNodes = false;
        cancelCheckPathThread = false;

        ingameSettings();
        watchForEvents();
        FNVFlightMasterSettings.Load();
        applyDefaultNodes();
        MovementEvents.OnMovementPulse += MovementEventsOnOnMovementPulse;
        MovementEvents.OnSeemStuck += MovementEventsOnOnSeemStuck;

        scanNearbyTaxi.Start();
        flightMasterLoop();
    }

    public void Dispose()
    {
        _runScan = false;
        cancelCheckPathThread = true;
        _isLaunched = false;
        _updateNodes = false;
        MovementEvents.OnMovementPulse -= MovementEventsOnOnMovementPulse;
        MovementEvents.OnSeemStuck -= MovementEventsOnOnSeemStuck;
        FNVFlightMasterSettings.CurrentSettings.Save();
        Logging.Write("[VanillaFlightMaster]: Flight Master disposed");
    }

    public void Settings()
    {
        FNVFlightMasterSettings.Load();
        FNVFlightMasterSettings.CurrentSettings.ToForm();
        FNVFlightMasterSettings.CurrentSettings.Save();
    }

    public static void ingameSettings()
    {
        if(wManager.wManagerSetting.CurrentSetting.FlightMasterTaxiUse)
        {
            Logging.Write("[VanillaFlightMaster]: WRobots Taxi is enabled, going to disable it...");
            wManager.wManagerSetting.CurrentSetting.FlightMasterTaxiUse = false;
        }
    }

    public static void applyDefaultNodes()
    {
        if(ObjectManager.Me.PlayerRace == PlayerFactions.NightElf)
        {
            FNVFlightMasterSettings.CurrentSettings.Darkshore = true;
            FNVFlightMasterSettings.CurrentSettings.Teldrassil = true;
        }

        if(ObjectManager.Me.PlayerRace == PlayerFactions.Human)
            FNVFlightMasterSettings.CurrentSettings.Stormwind = true;

        if(ObjectManager.Me.PlayerRace == PlayerFactions.Dwarf || ObjectManager.Me.PlayerRace == PlayerFactions.Gnome)
            FNVFlightMasterSettings.CurrentSettings.Ironforge = true;

    }

    private void flightMasterLoop()
    {

        while(Products.IsStarted && _isLaunched)
        {
            if(!Products.InPause && _takenTaxi || _timer)
            {
                while(ObjectManager.Me.IsOnTaxi)
                {
                    Thread.Sleep(1000);
                }

                
                for(int timer = FNVFlightMasterSettings.CurrentSettings.pauseTaxiTime; timer > 0 && _timer; timer -= 1000)
                {
                    Thread.Sleep(1000);
                }
                

                if(!scanNearbyTaxi.IsAlive)
                {
                    Logging.Write("Taxi scan not running, restarting...");
                    scanNearbyTaxi.Start();
                }
                if(!checkPathDuringRun.IsAlive && FNVFlightMasterSettings.CurrentSettings.useCheckPathThread)
                {
                    Logging.Write("Check path is not running, restarting...");
                    checkPathDuringRun.Start();
                }

                resetTaxi();
            }

            Thread.Sleep(5000);
        }

        Dispose();
    }

    private static void resetTaxi()
    {
        while(ObjectManager.Me.IsOnTaxi)
        {
            Thread.Sleep(5000);
        }

        Thread.Sleep(Usefuls.Latency * 3 + 1500);

        Logging.Write("[VanillaFlightMaster]: Reset taxi");
        _takenTaxi = false;
        from = (FlightMasterDB)null;
        to = (FlightMasterDB)null;
        _timer = false;
        checkPath = true;
        checkPathActive = false;
        checkPathActiveFM = (FlightMasterDB)null;
    }

    private void watchForEvents()
    {

        EventsLuaWithArgs.OnEventsLuaWithArgs += (LuaEventsId id, List<string> args) =>
        {
            //_updateNodes = true;
            if(id == wManager.Wow.Enums.LuaEventsId.TAXIMAP_OPENED && FNVFlightMasterSettings.CurrentSettings.updateTaxi)
            {
                if(!_updateNodes)
                {
                    _updateNodes = true;
                    //Logging.Write("[VanillaFlightMaster]: Taxi map opened");
                    List<FlightMasterDB> dbUpdate = fillDB();
                    int node = -1;

                    foreach(var temp in dbUpdate)
                    {
                        if(temp.continent.Equals(checkContinent()))
                        {
                            node = -1;
                            node = wManager.Wow.Helpers.Lua.LuaDoString<int>("for i=0,30 do if string.find(TaxiNodeName(i),'" + temp.name + "') then return i end end return -1");
                            //Logging.Write("Node is: " + node);

                            if(node == -1 && temp.alreadyDiscovered)
                            {
                                Logging.Write("[VanillaFlightMaster]: Taxi node " + temp.name + " has not been discovered so far");
                                temp.alreadyDiscovered = false;
                                FNVFlightMasterSettings.flightMasterSaveChanges(temp, false);
                            }
                            else if(node != -1 && !temp.alreadyDiscovered)
                            {
                                Logging.Write("[VanillaFlightMaster]: Taxi node " + temp.name + " has already been discovered");
                                temp.alreadyDiscovered = true;
                                FNVFlightMasterSettings.flightMasterSaveChanges(temp, true);
                            }

                        }
                    }
                    _updateNodes = false;
                    Thread.Sleep(Usefuls.Latency * 5 + 5000);
                }
            }
        };
    }

    private static void MovementEventsOnOnSeemStuck()
    {
        Vector3 searingGorgeGate = new Vector3(-6033.529f, -2490.157f, 310.9456f);

        if((Usefuls.MapZoneName.Contains("Loch Modan") || Usefuls.MapZoneName.Contains("Searing Gorge")) && ObjectManager.Me.Position.DistanceTo2D(searingGorgeGate) < 50 && FNVFlightMasterSettings.CurrentSettings.pauseSearingGorge)
        {
            stuckCounter++;
            if(stuckCounter >= 5)
            {
                Logging.Write("[VanillaFlightMaster]: Repeated stucks detected at the locked gate between Loch Modan and Searing Gorge. Going to stop bot, to prevent getting caught");
                stuckCounter = 0;
                Products.ProductStop();
            }
        }
        else
        {
            stuckCounter = 0;
        }

        if(_timer || _takenTaxi)
        {
            Logging.Write("[VanillaFlightMaster]: SeemStuck detected, reset taxi to help solving it");
            resetTaxi();
        }
    }


    private static void MovementEventsOnOnMovementPulse(List<Vector3> points, CancelEventArgs cancelable)
    {
               // Logging.Write("Enter Movement event path count: " + points.Count);

                statusDiscover = Logging.Status;
                if(_taxiToDiscover && !discoverTaxiNode.Equals((FlightMasterDB)null) && !_discoverInProessing && !_updateNodes && !statusDiscover.Contains("Boat") && !statusDiscover.Contains("Ship"))
                {
                    // Logging.Write("Enter _taxiToDiscover");
                    _discoverInProessing = true;
                    Thread.Sleep(Usefuls.Latency + 500);
                    cancelable.Cancel = true;
                    checkPathActive = true;
                    checkPathActiveFM = discoverTaxiNode;

                    discoverTaxi(discoverTaxiNode);

                    Thread.Sleep(Usefuls.Latency * 3);
                    cancelable.Cancel = false;
                    checkPathActive = false;
                }

            if(changer && !_updateNodes && !inProcessing && ObjectManager.Me.IsAlive) //&& points.Count > 1
            {
                //Logging.Write("Enter take taxi actual step");
                changer = false;
                if(!_taxiToDiscover && !_timer && !_takenTaxi && ObjectManager.Me.Position.DistanceTo(points.Last<Vector3>()) > FNVFlightMasterSettings.CurrentSettings.taxiTriggerDistance)
                {


                    status = Logging.Status;          
                    if(FNVFlightMasterSettings.CurrentSettings.skipIfFollowPath && status.Contains("Follow Path") && !status.Contains("Resurrect") && calculateRealDistance(ObjectManager.Me.Position, points.Last<Vector3>()) < FNVFlightMasterSettings.CurrentSettings.skipIfFollowPathDistance)
                    {
                        Logging.Write("[VanillaFlightMaster]: Currently following path or distance to start (" + calculateRealDistance(ObjectManager.Me.Position, points.Last<Vector3>()) + " yards) is smaller than setting value (" + FNVFlightMasterSettings.CurrentSettings.skipIfFollowPathDistance + " yards)");
                        Thread.Sleep(1000);
                        cancelable.Cancel = false;
                        inProcessing = false;
                        checkPathActive = true;
                        changer = true;
                        _timer = true;
                        return;
                    }

                    destinationVector = points.Last<Vector3>();
                    saveDistance = calculateRealDistance(ObjectManager.Me.Position, points.Last<Vector3>());

                    Thread.Sleep(Usefuls.Latency + 500);
                    cancelable.Cancel = true;

                    if(!inProcessing)
                    {
                        from = getClosestFlightMasterFrom();
                        to = getClosestFlightMasterTo();
                    }

                    Thread.Sleep(1000);

                    if(!from.name.Contains(to.name) && !to.name.Contains("null") && !to.name.Contains("FlightMaster") && !from.name.Contains("null") && !from.Equals(to) && calculateRealDistance(ObjectManager.Me.Position, from.position) + calculateRealDistance(to.position, destinationVector) + FNVFlightMasterSettings.CurrentSettings.shorterMinDistance <= saveDistance)
                    {

                        Logging.Write("[VanillaFlightMaster]: Shorter path detected, taking Taxi from " + from.name + " to " + to.name);
                        inProcessing = true;
                        checkPathActive = true;
                        checkPathActiveFM = from;
                        //cancelable.Cancel = true;
                        takeTaxi(from, to);

                        //Logging.Write("After take taxi");
                        Thread.Sleep(1000);
                        cancelable.Cancel = false;
                        inProcessing = false;
                        checkPathActive = true;

                    }
                    else
                    {
                        Logging.Write("[VanillaFlightMaster]: No shorter path available, skip flying");
                        cancelable.Cancel = false;
                        _timer = true;
                        inProcessing = false;
                    }
                }
                changer = true;
            }
            //Logging.Write("Finished MovementPulseEvent");
    }

    public static bool inCombat()
    {
        return Lua.LuaDoString<bool>("return UnitAffectingCombat('player');");
    }

    public static bool inCombatPet()
    {
        return Lua.LuaDoString<bool>("return UnitAffectingCombat('pet');");
    }


    Thread scanNearbyTaxi = new Thread(() =>
    {
        int scanTimer = 10000;
        List<FlightMasterDB> npcScan = fillDB();
        Logging.Write("[VanillaFlightMaster]: Taxi scan started");

        while(robotManager.Products.Products.IsStarted)
        {
            //Logging.Write("In Taxi scan thread loop");
            /* if(!_runScan)
             {
                 Logging.Write("[VanillaFlightMaster]: Taxi scan disposed");
                 break;
             }
             */
            if(_discoverTaxiTimer || _discoverInProessing)
            {
                Logging.Write("[VanillaFlightMaster]: Discover in processing or scan for nearby nodes paused");
                for(int i = FNVFlightMasterSettings.CurrentSettings.pauseTaxiTime; i > 0; i -= 1000)
                {
                    Thread.Sleep(1000);
                }
                _discoverTaxiTimer = false;
            }

            while(inCombat() || inCombatPet())
            {
                Thread.Sleep(5000);
            }

            //Pause while training First Aid in Darnassus, to avoid conflicts with HumanMasterPlugin
            string status = Logging.Status;
            while(status.Contains("First Aid") && Usefuls.MapZoneName.Contains("Teldrassil"))
            {
                Logging.Write("[VanillaFlightMaster]: HumanMasterPlugin trying to train First Aid. Pausing undiscovered node scan for five minutes to avoid conflicts");
                Thread.Sleep(300000);
            }

            if(Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause && !_taxiToDiscover && !ObjectManager.Me.IsOnTaxi)
            {
                foreach(var temp in npcScan)
                {
                    if(checkContinent() == temp.continent && !temp.alreadyDiscovered && ObjectManager.Me.Position.DistanceTo(temp.position) < FNVFlightMasterSettings.CurrentSettings.detectTaxiDistance)
                    {
                        taxiToDiscover = temp;
                        discoverTaxiNode = temp;
                        _taxiToDiscover = true;
                        Logging.Write("[VanillaFlightMaster]: Near undiscovered Taxi node found: " + temp.name);

                        Thread.Sleep(1000 + Usefuls.Latency);

                        while(!MovementManager.InMovement)
                        {
                            Thread.Sleep(100);
                        }

                        Reenable();
                    }
                }
            }
            Thread.Sleep(Usefuls.Latency * 10);
            npcScan = fillDB();
            Thread.Sleep(scanTimer);
        }

    });

    Thread checkPathDuringRun = new Thread(() =>
    {

        Logging.Write("[VanillaFlightMaster]: Path checker started");
        
        while(robotManager.Products.Products.IsStarted)
        {

            if(pauseCheckPathThread)
            {
                Thread.Sleep(5000);
                continue;
            }

            if(_timer)
            {
                Thread.Sleep(5000);
                continue;
            }

            if(cancelCheckPathThread)
            {
                Logging.Write("[VanillaFlightMaster]: Check path thread disposed");
                break;
            }

            
            if(checkPathActive)
            {
                Thread.Sleep(5000);
                status = Logging.Status;
                if(MovementManager.CurrentPath.Last<Vector3>().DistanceTo(checkPathActiveFM.position) > 10 && !checkPathActiveFM.Equals((FlightMasterDB)null) && !status.Contains("Resurrect") && !status.Contains("To Town"))
                {
                    Logging.Write("[VanillaFlightMaster: Current path does not lead to Flight Master of " + checkPathActiveFM.name + ". Reset path...");
                    checkPathActive = false;
                    Reenable();
                }
                Thread.Sleep(5000);
            }
            Thread.Sleep(5000);
        }
        

    });

    //By Matenia
    private static async void Reenable()
    {
        //Logging.Write("Enter reenable");
        await Task.Run(() =>
        {
            Products.InPause = true;
            if(ObjectManager.Me.WowClass == WoWClass.Hunter)
                Lua.LuaDoString("RotaOn = false");
            MovementManager.StopMove();
            MovementManager.CurrentPath.Clear();
            MovementManager.CurrentPathOrigine.Clear();
            Thread.Sleep(5000);
            Products.InPause = false;
            if(ObjectManager.Me.WowClass == WoWClass.Hunter)
                Lua.LuaDoString("RotaOn = true");
            Logging.Write("[VanillaFlightMaster]: Resetting pathing");
        });
    }

    private static float calculateRealDistance(Vector3 startVector, Vector3 destinationVector)
    {
        float distance = 0;

        List<Vector3> realDistance = new List<Vector3>();

        realDistance = PathFinder.FindPath(startVector, destinationVector);

        for(int i = 0; i < realDistance.Count - 1; i++)
        {
            distance = distance + realDistance[i].DistanceTo2D(realDistance[i + 1]);
        }
        //Logging.Write("Real distance is: " + distance);
        return distance;
    }

    public static FlightMasterDB getClosestFlightMasterFrom()
    {
        List<FlightMasterDB> FMLnfmd = fillDB();
        float tempDistance = 99999;
        FlightMasterDB returnObject = new FlightMasterDB("null", 0, new Vector3(0, 0, 0), false, false);

        foreach(var a in FMLnfmd)
        {
            if(a.alreadyDiscovered && a.position.DistanceTo(ObjectManager.Me.Position) < tempDistance && (a.continent == checkContinent()))
            {
                tempDistance = a.position.DistanceTo(ObjectManager.Me.Position);
                returnObject = a;
            }
        }
        return returnObject;
    }

    public static FlightMasterDB getClosestFlightMasterTo()
    {
        List<FlightMasterDB> FMLgcfmt = fillDB();
        float tempDistance = 99999;
        FlightMasterDB returnObject = new FlightMasterDB("null", 0, new Vector3(0, 0, 0), false, false);

        foreach(var a in FMLgcfmt)
        {
            if(a.alreadyDiscovered && a.position.DistanceTo(destinationVector) < tempDistance && (a.continent == checkContinent()))
            {
                tempDistance = a.position.DistanceTo(destinationVector);
                returnObject = a;
            }
        }
        return returnObject;
    }

    public static bool checkContinent()
    {
        if(Usefuls.ContinentId == (int)ContinentId.Kalimdor)
        {
            //Logging.Write("[VanillaFlightMaster]: Currently located in Kalimdor");
            return true;
        }
        else
        {
            //Logging.Write("[VanillaFlightMaster]: Currently located in Eastern Kingdoms");
            return false;
        }
    }

    public static void waitFlying(string destinationFlightMaster)
    {
        while(ObjectManager.Me.IsOnTaxi)
        {
            Logging.Write("[VanillaFlightMaster]: On taxi, waiting");
            Thread.Sleep(30000);
        }
        _takenTaxi = true;
        inProcessing = false;
        Thread.Sleep(5000);
        Reenable();
        Logging.Write("[VanillaFlightMaster]: Arrived at destination " + destinationFlightMaster + " , finished waiting");
    }

    public static List<FlightMasterDB> fillDB()
    {
        //FNVFlightMasterSettings.Load();
        //True = Kalimdor ; False = Eastern Kingdoms
        List<FlightMasterDB> FMListe = new List<FlightMasterDB>();
        FlightMasterDB Stormwind = new FlightMasterDB("Stormwind", 352, new Vector3(-8835.76f, 490.084f, 109.6157f), false, FNVFlightMasterSettings.CurrentSettings.Stormwind);
        FMListe.Add(Stormwind);
        FlightMasterDB ArathiHighlands = new FlightMasterDB("Arathi", 2835, new Vector3(-1240.03f, -2513.96f, 21.92969f), false, FNVFlightMasterSettings.CurrentSettings.ArathiHighlands);
        FMListe.Add(ArathiHighlands);
        FlightMasterDB Ashenvale = new FlightMasterDB("Ashenvale", 4267, new Vector3(2828.4f, -284.3f, 106.7f), true, FNVFlightMasterSettings.CurrentSettings.Ashenvale);
        FMListe.Add(Ashenvale);
        FlightMasterDB Darkshore = new FlightMasterDB("Darkshore", 3841, new Vector3(6343.2f, 561.651f, 15.79876f), true, FNVFlightMasterSettings.CurrentSettings.Darkshore);
        FMListe.Add(Darkshore);
        FlightMasterDB Stranglethorn = new FlightMasterDB("Stranglethorn", 2859, new Vector3(-14477.9f, 464.101f, 36.38163f), false, FNVFlightMasterSettings.CurrentSettings.StranglethornValley);
        FMListe.Add(Stranglethorn);
        FlightMasterDB Duskwood = new FlightMasterDB("Duskwood", 2409, new Vector3(-10513.8f, -1258.79f, 41.43174f), false, FNVFlightMasterSettings.CurrentSettings.Duskwood);
        FMListe.Add(Duskwood);
        FlightMasterDB FeralasFeathermoon = new FlightMasterDB("Feathermoon", 8019, new Vector3(-4370.5f, 3340f, 12f), true, FNVFlightMasterSettings.CurrentSettings.FeralasFeathermoon);
        FMListe.Add(FeralasFeathermoon);
        FlightMasterDB FeralasThalanaar = new FlightMasterDB("Thalanaar", 4319, new Vector3(-4491f, -781f, -40f), true, FNVFlightMasterSettings.CurrentSettings.FeralasThalanaar);
        FMListe.Add(FeralasThalanaar);
        FlightMasterDB Tanaris = new FlightMasterDB("Tanaris", 7823, new Vector3(-7224.9f, -3738.2f, 8.4f), true, FNVFlightMasterSettings.CurrentSettings.Tanaris);
        FMListe.Add(Tanaris);
        FlightMasterDB Hinterlands = new FlightMasterDB("The Hinterlands", 8018, new Vector3(282.1f, -2001.3f, 194.1f), false, FNVFlightMasterSettings.CurrentSettings.TheHinterlands);
        FMListe.Add(Hinterlands);
        FlightMasterDB Ironforge = new FlightMasterDB("Ironforge", 1573, new Vector3(-4821.13f, -1152.4f, 502.2116f), false, FNVFlightMasterSettings.CurrentSettings.Ironforge);
        FMListe.Add(Ironforge);
        FlightMasterDB Menethil = new FlightMasterDB("Wetlands", 1571, new Vector3(-3793.2f, -782.052f, 9.014864f), false, FNVFlightMasterSettings.CurrentSettings.Wetlands);
        FMListe.Add(Menethil);
        FlightMasterDB TheBarrens = new FlightMasterDB("The Barrens", 16227, new Vector3(-898.246f, -3769.65f, 11.71021f), true, FNVFlightMasterSettings.CurrentSettings.TheBarrens);
        FMListe.Add(TheBarrens);
        FlightMasterDB Redridge = new FlightMasterDB("Redridge", 931, new Vector3(-9435.8f, -2234.79f, 69.43174f), false, FNVFlightMasterSettings.CurrentSettings.RedridgeMountains);
        FMListe.Add(Redridge);
        FlightMasterDB Teldrassil = new FlightMasterDB("Teldrassil", 3838, new Vector3(8640.58f, 841.118f, 23.26363f), true, FNVFlightMasterSettings.CurrentSettings.Teldrassil);
        FMListe.Add(Teldrassil);
        FlightMasterDB Southshore = new FlightMasterDB("Hillsbrad", 2432, new Vector3(-715.146f, -512.134f, 26.54455f), false, FNVFlightMasterSettings.CurrentSettings.HillsbradFoothills);
        FMListe.Add(Southshore);
        FlightMasterDB Stonetalon = new FlightMasterDB("Stonetalon Mountains", 4407, new Vector3(2682.83f, 1466.45f, 233.6483f), true, FNVFlightMasterSettings.CurrentSettings.StonetalonMountains);
        FMListe.Add(Stonetalon);
        FlightMasterDB Thelsamar = new FlightMasterDB("Loch Modan", 1572, new Vector3(-5424.85f, -2929.87f, 347.5623f), false, FNVFlightMasterSettings.CurrentSettings.LochModan);
        FMListe.Add(Thelsamar);
        FlightMasterDB Theramore = new FlightMasterDB("Dustwallow Marsh", 4321, new Vector3(-3828.88f, -4517.51f, 10.66067f), true, FNVFlightMasterSettings.CurrentSettings.DustwallowMarsh);
        FMListe.Add(Theramore);
        FlightMasterDB WesternP = new FlightMasterDB("Western Pleaguelands", 12596, new Vector3(928.3f, -1429.1f, 64.8f), false, FNVFlightMasterSettings.CurrentSettings.WesternPlaguelands);
        FMListe.Add(WesternP);
        FlightMasterDB Westfall = new FlightMasterDB("Westfall", 523, new Vector3(-10628.8f, 1037.79f, 34.43174f), false, FNVFlightMasterSettings.CurrentSettings.Westfall);
        FMListe.Add(Westfall);
        FlightMasterDB EasternP = new FlightMasterDB("Eastern Pleaguelands", 12617, new Vector3(2269.9f, -5345.4f, 86.9f), false, FNVFlightMasterSettings.CurrentSettings.EasternPlaguelands);
        FMListe.Add(EasternP);
        FlightMasterDB SearingGorge = new FlightMasterDB("Searing Gorge", 2941, new Vector3(-6559.1f, -1169.4f, 309.8f), false, FNVFlightMasterSettings.CurrentSettings.SearingGorge);
        FMListe.Add(SearingGorge);
        FlightMasterDB BurningSteppes = new FlightMasterDB("Burning Steppes", 2299, new Vector3(-8365.1f, -2758.5f, 185.6f), false, FNVFlightMasterSettings.CurrentSettings.BurningSteppes);
        FMListe.Add(BurningSteppes);
        FlightMasterDB BlastedLands = new FlightMasterDB("Blasted Lands", 8609, new Vector3(-11110.2f, -3437.1f, 79.2f), false, FNVFlightMasterSettings.CurrentSettings.BlastedLands);
        FMListe.Add(BlastedLands);
        FlightMasterDB Azshara = new FlightMasterDB("Azshara", 12577, new Vector3(2718.2f, -3880.8f, 101.4f), true, FNVFlightMasterSettings.CurrentSettings.Azshara);
        FMListe.Add(Azshara);
        FlightMasterDB Felwood = new FlightMasterDB("Felwood", 12578, new Vector3(6204.2f, -1951.4f, 571.3f), true, FNVFlightMasterSettings.CurrentSettings.Felwood);
        FMListe.Add(Felwood);
        FlightMasterDB Winterspring = new FlightMasterDB("Winterspring", 11138, new Vector3(6800.5f, -4742.4f, 701.5f), true, FNVFlightMasterSettings.CurrentSettings.Winterspring);
        FMListe.Add(Winterspring);
        FlightMasterDB UngoroCreater = new FlightMasterDB("goro Crater", 10583, new Vector3(-6110.5f, -1140.4f, -186.9f), true, FNVFlightMasterSettings.CurrentSettings.UngoroCrater);
        FMListe.Add(UngoroCreater);
        FlightMasterDB Silithus = new FlightMasterDB("Silithus", 15177, new Vector3(-6758.6f, 775.6f, 89f), true, FNVFlightMasterSettings.CurrentSettings.Silithus);
        FMListe.Add(Silithus);
        FlightMasterDB Desolace = new FlightMasterDB("Desolace", 6706, new Vector3(136f, 1326f, 193f), true, FNVFlightMasterSettings.CurrentSettings.Desolace);
        FMListe.Add(Desolace);
        return FMListe;
    }

    /*
    public static bool validFlight(String from, String to)
    {
        bool von = false;
        bool zu = false;
        List<FlightMasterDB> FMLvf = fillDB();

        for(int i = 0; i < FMLvf.Count; i++)
        {
            if(FMLvf[i].name.Contains(from))
            {
                von = FMLvf[i].continent;
            }
            if(FMLvf[i].name.Contains(to))
            {
                zu = FMLvf[i].continent;
            }
        }
        return von != zu;
    }

    
    public static bool discoveredTaxiNodes(String from, String to)
    {
        List<FlightMasterDB> FMLDTN = fillDB();

        foreach(var ele in FMLDTN)
        {
            if(ele.name.Contains(from))
            {
                //Logging.Write("Test 1");
                if(!ele.alreadyDiscovered)
                {
                    Logging.Write("[VanillaFlightMaster]: Taxi node from " + ele.name + " has not been discovered so far. Abort taking taxi.");
                    return false;
                }
            }
        }

        foreach(var ele in FMLDTN)
        {
            //Logging.Write("Test 2");
            if(ele.name.Contains(to))
            {
                if(!ele.alreadyDiscovered)
                {
                    Logging.Write("[VanillaFlightMaster]: Taxi node to " + ele.name + " has not been discovered so far. Abort taking taxi.");
                    return false;
                }
            }
        }
        //Logging.Write("Test 3");
        return true;
    }
    */

    private static void takeTaxi(FlightMasterDB from, FlightMasterDB to)
    {
        //Logging.Write("Taking taxi from " + from.name + " to " + to.name);
        // Logging.Write("Distance: " + ObjectManager.Me.Position.DistanceTo(from.position));

        if(wManager.Wow.Bot.Tasks.GoToTask.ToPosition(from.position, 3.5f, false, context => Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause && !Conditions.IsAttackedAndCannotIgnore))
        {
            if(wManager.Wow.Bot.Tasks.GoToTask.ToPositionAndIntecractWithNpc(from.position, from.NPCId, -1, false, context => Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause && !Conditions.IsAttackedAndCannotIgnore, false))
            {
                //Logging.Write("Enter select taxi");
                //Logging.Write("FROM OBJECT: " + from.name);
                while(!ObjectManager.Me.IsOnTaxi)
                {
                    if(ObjectManager.Me.IsMounted)
                        wManager.Wow.Bot.Tasks.MountTask.DismountMount(false, false, 100);
                    

                    Usefuls.SelectGossipOption(GossipOptionsType.taxi);

                    Thread.Sleep(Usefuls.Latency + 1500);

                    while(_updateNodes)
                    {
                        Logging.Write("[VanillaFlightMaster]: Taxi node update in progress, waiting...");
                        Thread.Sleep(10000);
                    }

                    int node = Lua.LuaDoString<int>("for i=0,30 do if string.find(TaxiNodeName(i),'" + to.name + "') then return i end end");
                    Lua.LuaDoString("TakeTaxiNode(" + node + ")");
                    Logging.Write("[VanillaFlightMaster]: Taking Taxi from " + from.name + " to " + to.name);
                    Thread.Sleep(Usefuls.Latency + 500);
                    robotManager.Helpful.Keyboard.DownKey(wManager.Wow.Memory.WowMemory.Memory.WindowHandle, System.Windows.Forms.Keys.Escape);
                    Thread.Sleep(Usefuls.Latency + 2500);
                    if(!ObjectManager.Me.IsOnTaxi)
                        wManager.Wow.Bot.Tasks.GoToTask.ToPositionAndIntecractWithNpc(from.position, from.NPCId, -1, false, context => Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause && !Conditions.IsAttackedAndCannotIgnore, false);
                }

                if(ObjectManager.Me.IsOnTaxi)
                {
                    //Logging.Write("[VanillaFlightMaster]: Taking taxi successful!");
                    waitFlying(to.name);
                }
            }
        }
    }

    private static void discoverTaxi(FlightMasterDB flightMasterToDiscover)
    {

        FNVFlightMasterSettings.Load();
        List<FlightMasterDB> FMLdt = fillDB();

        if(wManager.Wow.Bot.Tasks.GoToTask.ToPosition(flightMasterToDiscover.position, 3.5f, false, context => Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause && !Conditions.IsAttackedAndCannotIgnore))
        {

        wManager.Wow.Bot.Tasks.GoToTask.ToPosition(flightMasterToDiscover.position, 3.5f, false, context => Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause && !Conditions.IsAttackedAndCannotIgnore);

            if(wManager.Wow.Bot.Tasks.GoToTask.ToPositionAndIntecractWithNpc(flightMasterToDiscover.position, flightMasterToDiscover.NPCId, -1, false, context => Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause && !Conditions.IsAttackedAndCannotIgnore, false))
            {
                wManager.wManagerSetting.ClearBlacklistOfCurrentProductSession();
                wManager.Wow.Bot.Tasks.GoToTask.ToPositionAndIntecractWithNpc(flightMasterToDiscover.position, flightMasterToDiscover.NPCId, -1, false, context => Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause && !Conditions.IsAttackedAndCannotIgnore, false);

                if(ObjectManager.Me.IsMounted)
                        wManager.Wow.Bot.Tasks.MountTask.DismountMount(false, false, 100);

                Usefuls.SelectGossipOption(GossipOptionsType.taxi);
                Thread.Sleep(Usefuls.Latency + 1500);

                while(_updateNodes)
                {
                    Logging.Write("[VanillaFLightMaster]: Taxi node update in progress...");
                    Thread.Sleep(10000);
                }

                Logging.Write("[VanillaFlightMaster]: Flight Master " + flightMasterToDiscover.name + " discovered");
                flightMasterToDiscover.alreadyDiscovered = true;
                FNVFlightMasterSettings.flightMasterSaveChanges(flightMasterToDiscover, true);

                Thread.Sleep(Usefuls.Latency * 5);

                timer = 0;
                //_timer = true;
                discoverTaxiNode = (FlightMasterDB)null;
                _taxiToDiscover = false;
                _discoverInProessing = false;
                _discoverTaxiTimer = true;
                Reenable();
                return;
            }
        }
        _discoverInProessing = false;
        return;
    }
}


    public class FlightMasterDB
    {
        public FlightMasterDB(String name, int NPCId, Vector3 position, bool continent, bool alreadyDiscovered)
        {
            this.name = name;
            this.NPCId = NPCId;
            this.position = position;
            this.continent = continent;
            this.alreadyDiscovered = alreadyDiscovered;
        }

        public int NPCId { get; set; }
        public Vector3 position { get; set; }
        public String name { get; set; }
        public bool continent { get; set; }
        public bool alreadyDiscovered { get; set; }

    }

    [Serializable]
    public class FNVFlightMasterSettings : Settings
    {
        public FNVFlightMasterSettings()
        {
            //Settings
            this.taxiTriggerDistance = 1000;
            this.pauseTaxiTime = 50000;
            this.detectTaxiDistance = 50;
            this.shorterMinDistance = 1000;
            this.skipIfFollowPath = true;
            this.updateTaxi = true;
            this.skipIfFollowPathDistance = 5000;
            this.useCheckPathThread = false;
            this.pauseSearingGorge = true;

            //FlightMaster discovered
            //Eastern Kingdoms
            this.ArathiHighlands = false;
            this.Wetlands = false;
            this.WesternPlaguelands = false;
            this.EasternPlaguelands = false;
            this.HillsbradFoothills = false;
            this.TheHinterlands = false;
            this.LochModan = false;
            this.Ironforge = false;
            this.SearingGorge = false;
            this.BurningSteppes = false;
            this.RedridgeMountains = false;
            this.Stormwind = false;
            this.Westfall = false;
            this.Duskwood = false;
            this.StranglethornValley = false;
            this.BlastedLands = false;

            //Kalimdor
            this.Teldrassil = false;
            this.Darkshore = false;
            this.Winterspring = false;
            this.Azshara = false;
            this.Ashenvale = false;
            this.StonetalonMountains = false;
            this.Desolace = false;
            this.TheBarrens = false;
            this.Tanaris = false;
            this.FeralasFeathermoon = false;
            this.FeralasThalanaar = false;
            this.UngoroCrater = false;
            this.DustwallowMarsh = false;
            this.Silithus = false;
            this.Moonglade = false;
            this.Felwood = false;

        }

    public static void flightMasterSaveChanges(FlightMasterDB needToChange, bool value)
    {

        if(needToChange.name.Contains("Arathi"))
            CurrentSettings.ArathiHighlands = value;

        if(needToChange.name.Contains("Wetlands"))
            CurrentSettings.Wetlands = value;

        if(needToChange.name.Contains("Western"))
            CurrentSettings.WesternPlaguelands = value;

        if(needToChange.name.Contains("Eastern"))
            CurrentSettings.EasternPlaguelands = value;

        if(needToChange.name.Contains("Hillsbrad"))
            CurrentSettings.HillsbradFoothills = value;

        if(needToChange.name.Contains("Hinterlands"))
            CurrentSettings.TheHinterlands = value;

        if(needToChange.name.Contains("Modan"))
            CurrentSettings.LochModan = value;

        if(needToChange.name.Contains("Ironforge"))
            CurrentSettings.Ironforge = value;

        if(needToChange.name.Contains("Searing"))
            CurrentSettings.SearingGorge = value;

        if(needToChange.name.Contains("Burning"))
            CurrentSettings.BurningSteppes = value;

        if(needToChange.name.Contains("Redridge"))
            CurrentSettings.RedridgeMountains = value;

        if(needToChange.name.Contains("Stormwind"))
            CurrentSettings.Stormwind = value;

        if(needToChange.name.Contains("Westfall"))
            CurrentSettings.Westfall = value;

        if(needToChange.name.Contains("Duskwood"))
            CurrentSettings.Duskwood = value;

        if(needToChange.name.Contains("Stranglethorn"))
            CurrentSettings.StranglethornValley = value;

        if(needToChange.name.Contains("Blasted"))
            CurrentSettings.BlastedLands = value;

        if(needToChange.name.Contains("Teldrassil"))
            CurrentSettings.Teldrassil = value;

        if(needToChange.name.Contains("Darkshore"))
            CurrentSettings.Darkshore = value;

        if(needToChange.name.Contains("Winterspring"))
            CurrentSettings.Winterspring = value;

        if(needToChange.name.Contains("Azshara"))
            CurrentSettings.Azshara = value;

        if(needToChange.name.Contains("Ashenvale"))
            CurrentSettings.Ashenvale = value;

        if(needToChange.name.Contains("Stonetalon"))
            CurrentSettings.StonetalonMountains = value;

        if(needToChange.name.Contains("Desolace"))
            CurrentSettings.Desolace = value;

        if(needToChange.name.Contains("Tanaris"))
            CurrentSettings.Tanaris = value;

        if(needToChange.name.Contains("Barrens"))
            CurrentSettings.TheBarrens = value;

        if(needToChange.name.Contains("Feathermoon"))
            CurrentSettings.FeralasFeathermoon = value;

        if(needToChange.name.Contains("Thalanaar"))
            CurrentSettings.FeralasThalanaar = value;

        if(needToChange.name.Contains("ro Crater"))
            CurrentSettings.UngoroCrater = value;

        if(needToChange.name.Contains("Dustwallow"))
            CurrentSettings.DustwallowMarsh = value;

        if(needToChange.name.Contains("Silithus"))
            CurrentSettings.Silithus = value;

        if(needToChange.name.Contains("Felwood"))
            CurrentSettings.Felwood = value;

        FNVFlightMasterSettings.CurrentSettings.Save();
        Thread.Sleep(2500);
        try
        {
            FNVFlightMasterSettings.CurrentSettings = Load<FNVFlightMasterSettings>(AdviserFilePathAndName("VanillaFlightMaster_DB", ObjectManager.Me.Name + "." + Usefuls.RealmName));
        }
        catch(Exception e)
        {
            Logging.Write("[VanillaFlightMaster]: Error when trying to reload DB file -> " + e);
        }

        Logging.Write("[VanillaFlightMaster]: Settings saved of Flight Master " + needToChange.name);
        return;
    }


        public static FNVFlightMasterSettings CurrentSettings { get; set; }

        public bool Save()
        {
            try
            {
                return Save(AdviserFilePathAndName("VanillaFlightMaster_DB", ObjectManager.Me.Name + "." + Usefuls.RealmName));
            }
            catch(Exception e)
            {
                Logging.WriteDebug("VanillaFlightMaster_DB => Save(): " + e);
                return false;
            }
        }


    public static bool Load()
    {
        try
        {
            if(File.Exists(AdviserFilePathAndName("VanillaFlightMaster_DB", ObjectManager.Me.Name + "." + Usefuls.RealmName)))
            {
                FNVFlightMasterSettings.CurrentSettings = Load<FNVFlightMasterSettings>(AdviserFilePathAndName("VanillaFlightMaster_DB", ObjectManager.Me.Name + "." + Usefuls.RealmName));
                return true;
            }

            FNVFlightMasterSettings.CurrentSettings = new FNVFlightMasterSettings();
        }
        catch(Exception e)
        {
            Logging.WriteDebug("VanillaFlightMaster_DB => Load(): " + e);
        }
        return false;
    }

    [Setting]
    [DefaultValue(1000)]
    [Category("1 - Main")]
    [DisplayName("Trigger Distance")]
    [Description("Sets how long your distance to your destination has to be, to trigger use of taxi")]
    public int taxiTriggerDistance { get; set; }

    [Setting]
    [DefaultValue(50000)]
    [Category("1 - Main")]
    [DisplayName("Pause Taxi Time")]
    [Description("Sets how long taxi is paused after use, to avoid loops. Only change it, if you experience issues")]

    public int pauseTaxiTime { get; set; }
    [Setting]
    [DefaultValue(50)]
    [Category("1 - Main")]
    [DisplayName("Discover Distance")]
    [Description("Min distance to discover an undiscovered taxi node")]

    public int detectTaxiDistance { get; set; }
    [Setting]
    [DefaultValue(1000)]
    [Category("1 - Main")]
    [DisplayName("Shorter Path Min")]
    [Description("Sets how much shorter a path has to be, to trigger taxi")]
    public int shorterMinDistance { get; set; }

    [Setting]
    [DefaultValue(false)]
    [Category("1 - Main")]
    [DisplayName("Use check path thread")]
    [Description("Checks if current path leads to Flight Master, while take taxi is running. Resets path, if otherwise")]
    public bool useCheckPathThread { get; set; }

    [Setting]
    [DefaultValue(true)]
    [Category("2 - Useful")]
    [DisplayName("1. Skip if Follow Path / Boat step")]
    [Description("Skips take taxi, if currently executing a Follow Path or Boat Quester step. When running a profile with dedicated paths")]
    public bool skipIfFollowPath { get; set; }

    [Setting]
    [DefaultValue(true)]
    [Category("2 - Useful")]
    [DisplayName("2. Update taxi nodes")]
    [Description("Scans and updates all entries on the taxi map of the current continent, if they have already been discovered. Triggers, when the taxi map is opened")]
    public bool updateTaxi { get; set; }

    [Setting]
    [DefaultValue(5000)]
    [Category("2 - Useful")]
    [DisplayName("1.1 Skip if ... min distance")]
    [Description("Won't skip taxi min distance to destination")]
    public float skipIfFollowPathDistance { get; set; }

    [Setting]
    [DefaultValue(true)]
    [Category("2 - Useful")]
    [DisplayName("3. Stop bot at Searing Gorge gate")]
    [Description("Stops the bot, to prevent it from running into the Searing Gorge gate from Loch Modan and getting stuck over and over again")]
    public bool pauseSearingGorge { get; set; }
    

        //FlightMaster
        //Eastern Kingdoms
        public bool Stormwind { get; set; }
        public bool Westfall { get; set; }
        public bool RedridgeMountains { get; set; }
        public bool Duskwood { get; set; }
        public bool StranglethornValley { get; set; }
        public bool Ironforge { get; set; }
        public bool BurningSteppes { get; set; }
        public bool BlastedLands { get; set; }
        public bool SearingGorge { get; set; }
        public bool LochModan { get; set; }
        public bool Wetlands { get; set; }
        public bool ArathiHighlands { get; set; }
        public bool HillsbradFoothills { get; set; }
        public bool WesternPlaguelands { get; set; }
        public bool EasternPlaguelands { get; set; }
        public bool TheHinterlands { get; set; }

        //Kalimdor

        public bool Ashenvale { get; set; }
        public bool Azshara { get; set; }
        public bool Darkshore { get; set; }
        public bool Teldrassil { get; set; }
        public bool Desolace { get; set; }
        public bool DustwallowMarsh { get; set; }
        public bool Felwood { get; set; }
        public bool FeralasFeathermoon { get; set; }
        public bool FeralasThalanaar { get; set; }
        public bool Moonglade { get; set; }
        public bool Silithus { get; set; }
        public bool StonetalonMountains { get; set; }
        public bool Tanaris { get; set; }
        public bool TheBarrens { get; set; }
        public bool UngoroCrater { get; set; }
        public bool Winterspring { get; set; }

    }