ViperousQuest

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using COFarmerPluginLibrary;

namespace ViperousQuests {
    public class Plugin : COFarmerPluginLibrary.ICOFarmerPlugin {

        //Debug Message?
        public static bool debugMsg { get; set; }

        //Initialize Cases
        public static Cases mainCase = new Cases();




        public string Author { get { return "Viperous"; } }
        public string Name { get { return "ViperousQuests Plugin"; } }
        public string Version { get { return "0.0.1.0"; } }

        public void Main() {
            debugMsg = false;
        }

        public void OnClient(COFarmerClient _client) {

            if (debugMsg) { _client.Log("[ViperousQuests]: OnClient."); }

            if (mainCase.mainCase == Cases.MainCases.AbortScript) {
                //Plugin Error Tell restart Client and do nothing anymore!
                _client.Log("[ViperousQuests]: ERROR, Plugin will do nothing till next restart of COF! Sorry!");
                return;
            }

            //Register Methods
            _client.OnProcess += Plugin.OnProcess;


            //Register Commands
            _client.AddCommand("vq_savethetree", new OnCommandDelegate(Plugin.SaveTheTree));

            _client.AddCommand("vq_showdew", new OnCommandDelegate(Plugin.ShowDew));

            _client.AddCommand("vq_abort", new OnCommandDelegate(Plugin.Abort));



            //A Client logged in, so create new QuestClasses and Cases
            Cases clientCase = new Cases();
            clientCase.resetCases();

            _client.Session.Add("currentCase", clientCase);


            //Create Quest Classes
            SaveTheTree clientQuestSaveTheTree = new SaveTheTree();
            _client.Session.Add("questSaveTheTree", clientQuestSaveTheTree);

        }

        public static void ShowDew(COFarmerClient _client, string _str, string[] _args) {
            SaveTheTree questSaveTheTree;
            if (!_client.GetSessionVariable("questSaveTheTree", out questSaveTheTree)) { mainCase.mainCase = Cases.MainCases.AbortScript; return; }

            _client.Log(Convert.ToString(questSaveTheTree.getUseDew()));
        }

        /// <summary>
        /// Method to Start the SaveTheTree Quest.
        /// </summary>
        /// <param name="_client">The Client Object</param>
        /// <param name="_str">Don't Know yet :D</param>
        /// <param name="__args">As Argument can be passed how many Dews should be used, if no passed it will use max 300.</param>
        /// <returns></returns>
        public static void SaveTheTree(COFarmerClient _client, string _str, string[] _args) {

            if (debugMsg) { _client.Log("[ViperousQuests]: SaveTheTree."); }

            SaveTheTree questSaveTheTree;
            Cases clientCase;

            //trying to get neccessary Objects, else abort
            if (!_client.GetSessionVariable("questSaveTheTree", out questSaveTheTree)) { mainCase.mainCase =Cases.MainCases.AbortScript; return; }
            if (!_client.GetSessionVariable("currentCase", out clientCase)) { mainCase.mainCase = Cases.MainCases.AbortScript; return; }

            if (clientCase.saveTheTreeCase != Cases.SaveTheTreeCases.Idle) {
                _client.Log("[ViperousQuests]: SaveTheTree quest allready started and running! Doing nothing");
                return;
            }

            uint dewCount;
            if (_args.Count() > 1) {
                try {
                    dewCount = Convert.ToUInt32(_args[1]);
                } catch ( Exception ) {
                    dewCount = 300;
                }
            } else {
                //Use 300 Dews
                dewCount = 300;
            }

            //Not less then 0 (can't be cause of var type) and not more than 300)
            if (dewCount < 0 || dewCount > 300) {
                dewCount = 300;
            }


            questSaveTheTree.setUseDews(dewCount);


            //Set the Case to SaveTheTree and savethetreeevencase to entry
            clientCase.questCase = Cases.QuestCases.SaveTheTree;
            clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.Entry;

        }


        public static void OnProcess(COFarmerClient _client, uint _time) {

            //if (debugMsg) { _client.Log("[ViperousQuests]: onProcess."); }

            if (mainCase.mainCase == Cases.MainCases.AbortScript) {
                //Plugin Error Tell restart Client and do nothing anymore!
                _client.Log("[ViperousQuests]: ERROR, Plugin will do nothing till next restart of COF! Sorry!");
                return;
            }

            Cases clientCase;
            SaveTheTree questSaveTheTree;

            //trying to get neccessary Objects, else abort
            if (!_client.GetSessionVariable("questSaveTheTree", out questSaveTheTree)) { mainCase.mainCase = Cases.MainCases.AbortScript; return; }
            if (!_client.GetSessionVariable("currentCase", out clientCase)) { mainCase.mainCase = Cases.MainCases.AbortScript; return; }

            if (clientCase.mainCase == Cases.MainCases.AbortScript) {
                //Stop the execution of the script and reset cases
                clientCase.resetCases();
            } else if (clientCase.mainCase == Cases.MainCases.RunScript) {
                switch (clientCase.questCase) {
                    case Cases.QuestCases.Idle:
                        //Simply do nothing :-)
                        break;
                    case Cases.QuestCases.SaveTheTree:
                        //Do the SaveTheTreeQuest. Use the Process Method of SaveTheTree Class
                        //  So this file doesnt get 1million lines long.
                        questSaveTheTree.onProcess(_client, _time, clientCase);
                        break;
                }
            }




        }

        /// <summary>
        /// Method that aborts the execution of scripts and pushes the Plugin to "Idle" mode.
        /// </summary>
        /// <param name="_client">The Client Object</param>
        /// <param name="_str">Don't Know yet :D</param>
        /// <param name="__args">Not Used</param>
        /// <returns></returns>
        public static void Abort(COFarmerClient _client, string _str, string[] _args) {
            if (debugMsg) { _client.Log("[ViperousQuests]: Abort."); }
            Cases clientCase;

            //trying to get neccessary Objects, else abort
            if (!_client.GetSessionVariable("currentCase", out clientCase)) { mainCase.mainCase = Cases.MainCases.AbortScript; return; }

            clientCase.mainCase = Cases.MainCases.AbortScript;
        }

        public void OnClientToServer(COFarmerClient Client, Packet Packet) {        }
        public void OnServerToClient(COFarmerClient Client, Packet Packet) {        }
    }
}

//---------------------cases.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ViperousQuests {
    public class Cases {

        public  enum MainCases {
            RunScript,
            AbortScript
        }

        public  enum QuestCases {
            Idle,
            SaveTheTree
        }

        public  enum SaveTheTreeCases {
            Idle,
            Entry,
            CheckPlace,
            Traveling,
            CheckDew,
            WaterTree,
            End,
        }


        public MainCases mainCase { get; set; }
        public QuestCases questCase { get; set; }
        public SaveTheTreeCases saveTheTreeCase { get; set; }

        public Cases() {
            resetCases();
        }

        public void resetCases() {
            mainCase = MainCases.RunScript;
            questCase = QuestCases.Idle;

            //Got to fill up on adding new Events!
            saveTheTreeCase = SaveTheTreeCases.Idle;
        }
    }
}

//--------------------------SaveTreeQuest
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using COFarmerPluginLibrary;

namespace ViperousQuests {
    class SaveTheTree {

        public uint useDews { get; set; }


        private int placeCheckedInRow { get; set; }

        private uint timeLastWatered { get; set; }
        private uint timeLastSkipped { get; set; }

        private Location lastLoc { get; set; }
        private uint lastLocTime { get; set; }





        //Static Defines

        private static int placeCheckInRowLimit = 5;


        private static uint travelingCheckMoveInterval = 500;

        private static int waterWaitTime = 14000;

        private static int waterWaitExceptionTime = 30000;


        private static Location treeLoc = new Location(1002, new Point(426, 389));

        private static int dewTypeID = 727386;

        private static uint[] treeNPCIds = new uint[] { 8949, 8950, 8951, 8952 };

        public SaveTheTree() {
            useDews = 300;
            placeCheckedInRow = 0;

            timeLastWatered = 0;
            timeLastSkipped = 0;


            lastLoc = null;
            lastLocTime = 0;
        }

        public void onProcess(COFarmerClient _client, uint _time, Cases _clientCase) {

            switch (_clientCase.saveTheTreeCase) {

                case Cases.SaveTheTreeCases.Idle:
                    //Should never come here
                    _client.Log("[ViperousQuests]Save the Tree: Quest in idle mode, this should never happen. Reseting Quest.");
                    _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.End;
                    break;
                case Cases.SaveTheTreeCases.Entry:
                    _client.Log("[ViperousQuests]Save the Tree: Starting quest.");
                    _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.CheckPlace;
                    break;

                case Cases.SaveTheTreeCases.CheckPlace:
                    if (ViperousQuests.Plugin.debugMsg) { _client.Log("[Debug][ViperousQuest]Save the Tree: CheckPlace"); }
                    //Check if your at right Position, if not Travel :D
                    Location curLoc = new Location(_client.DynamicMapID, _client.Location);

                    if (ViperousQuests.Plugin.debugMsg) { _client.Log("[Debug][ViperousQuest]Save the Tree: CheckPlace: CurLoc: X:" + curLoc.Coordinate.X + " Y: " + curLoc.Coordinate.Y); }

                    if (curLoc != treeLoc) {
                        if (ViperousQuests.Plugin.debugMsg) { _client.Log("[Debug][ViperousQuest]Save the Tree: CheckPlace: Travel"); }

                        //Something wrong, gotta Travel
                        _client.TravelTo(treeLoc.MapID, treeLoc.Coordinate);

                        _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.Traveling;

                        break;


                    } else {
                        //Right place proceed to next case
                        _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.CheckDew;
                    }

                    break;

                case Cases.SaveTheTreeCases.Traveling:
                    //Check if the Client is really Traveling

                    if (lastLoc == null) {
                        //first Check, save Cords and time
                        lastLoc = new Location(_client.DynamicMapID, _client.Location);
                        lastLocTime = _time;
                        break;
                    } else {
                        //Check if time is ready for a traveling check
                        if (_time - lastLocTime > travelingCheckMoveInterval) {
                            if (ViperousQuests.Plugin.debugMsg) { _client.Log("[Debug][ViperousQuest]Save the Tree: Traveling: Time to check if moving"); }
                            Location tmpLoc = new Location(_client.DynamicMapID, _client.Location);
                            lastLocTime = _time;
                            if (lastLoc == tmpLoc) {
                                //Client dont move, means he is at target or cant go to target, make a checkPlace
                                _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.CheckPlace;

                                //Dont change case so it will be checked again. To prevent a dead End count var
                                placeCheckedInRow++;

                                if (placeCheckedInRow > placeCheckInRowLimit) {
                                    //Error happend, abort this Quest!
                                    _client.Log("[ViperousQuests]Save the Tree: Error couldn't reach destination, tried: " + placeCheckedInRow + " times.");
                                    _client.Log("[ViperousQuests]Save the Tree: Aborting SaveTheTree quest.");

                                    _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.End;
                                    break;
                                }
                            } else {
                                //Client is moving do nothing :)
                            }
                            lastLoc = tmpLoc;
                        } else {
                            //Just do nothing and wait till next traveling check is up
                        }
                    }

                    break;

                case Cases.SaveTheTreeCases.CheckDew:
                    if (ViperousQuests.Plugin.debugMsg) { _client.Log("[Debug][ViperousQuest]Save the Tree: CheckDew"); }
                    //Check if there are Dews Left, or allready used enough Dews

                    if (BCOHelper.CountItemID(_client, dewTypeID) <= 0) {
                        //No Dews Left
                        //I hate Dialog Boxes
                        _client.AnswerNpc(6);
                        _client.AnswerNpc(6);

                        _client.Log("[ViperousQuests]Save the Tree: No Dews left in inventory, ending.");
                        _clientCase.saveTheTreeCase =Cases.SaveTheTreeCases.End;
                        break;
                    } else if (getUseDew() <= 0) {
                        //Desired Dew Count reached
                        //I hate Dialog Boxes
                        _client.AnswerNpc(6);
                        _client.AnswerNpc(6);

                        _client.Log("[ViperousQuests]Save the Tree: Desired Dew use count reached. Ending quest.");
                        _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.End;
                        break;
                    }

                    //Everything good, water the tree :)
                    _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.WaterTree;

                    break;

                case Cases.SaveTheTreeCases.WaterTree:
                    //Wait at least 14s since last time watered till try another time
                    if (_time - timeLastWatered >= waterWaitTime) {
                        //I hate Dialog Boxes
                        _client.AnswerNpc(6);
                        _client.AnswerNpc(6);

                        //Waited long enough, do another Water! Reset Last Skipped Timer
                        timeLastSkipped = _time;

                        // Tree can have multiple IDs, try all
                        for (int cnt = 0; cnt < treeNPCIds.Count(); cnt++) {
                            _client.ClickNpc(treeNPCIds[cnt]);
                        }

                        //Record time last Watered (well thats NOW :D)
                        timeLastWatered = _time;

                        //decrease count
                        setUseDews(getUseDew() - 1);

                        //Set case to CheckPlace
                        _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.CheckPlace;
                    }
                    //Not waited long enough, do another WaterTree try

                    //Check if we have an error and wait allready a long time
                    if (_time - timeLastSkipped > waterWaitExceptionTime) {
                        //Error happend, abort this Quest!
                        _client.Log("[ViperousQuests]Save the Tree: Error had to wait too long to water: " + waterWaitExceptionTime / 1000 + " s.");
                        _client.Log("[ViperousQuests]Save the Tree: Aborting SaveTheTree quest.");

                        _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.End;
                        break;
                    }
                    break;


                case Cases.SaveTheTreeCases.End:
                    _client.Log("[ViperousQuests]Save the Tree: The quest has been finished (or aborted, read the previous message.");
                    //Set thisQuest Case to Idle
                    _clientCase.saveTheTreeCase = Cases.SaveTheTreeCases.Idle;
                    _clientCase.questCase = Cases.QuestCases.Idle;
                    break;
            }
        }



        public void setUseDews(uint _dewCount){
            useDews = _dewCount;
        }
        public uint getUseDew(){
            return useDews;
        }

    }
}