Mine

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Threading;
using System.Net;
using System.Windows.Forms;
using System.Text.RegularExpressions;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using PaintDotNet;
using PaintDotNet.Data;
using PaintDotNet.SystemLayer;

namespace Wealth_Wars
{
    public partial class MapForm : Form
    {
        #region Variables

        public String[] mdbLoc = { "NE", "0", "0" };  //0 - NE|NW|SE|SW, 1- xCoord, 2 - yCoord 
        public static String[] mdbCenter = { "NE", "0", "0" }; //Location of "center" field of current minimap

        private DataBasePainter dataBasePainter = new DataBasePainter();
        private VMapDetails wwVmapDetails = new VMapDetails();
        private PathExecutor pathExecutor = new PathExecutor();
        private PossibleMoves possibleMoves = new PossibleMoves();
        private Document mapDBMultiLayerDoc;     //Layers: 0 - map, 1 - user pos, 2 - selected pos
        private DataBaseHandler dataBaseHandler = new DataBaseHandler();    //create the dbhandler class object
        private List<String> mapDBFieldSelectedList = new List<String>();  //List with coordinates to selected fields
        private List<String> mapPathList = new List<String>();      //List of choosen paths
        private delegate void SetMapDataCallback(String location, List<String> data);
        private delegate void SetMapDataAdditionalCallback(List<String> data);
        private delegate String HoverLocData(Point mouseLoc);
        private delegate Image MouseClickLoc(Point mouseLoc, int mapDBHScroll, int mapDBVScroll);
        private delegate void MapDBSCBarsRelocator(int offsetXY, int hvScroll, int mapMiniLocX, int mapMiniLocY);

        private int hSCBarVal = 0;
        private int vSCBarVal = 0;
        private int hOffsetBarVal = 0;
        private int vOffsetBarVal = 0;
        private int[] oldRealLoc = new int[2];        //real old user location
        private int[] oldXYLoc = new int[2];
        private ConnectForm conFormRef;

        public ConnectForm ConFormRef
        {
            get { return conFormRef; }
            set { ConFormRef = value; }
        }

        private String[] additionalDataStr = {
            "Money Aquired", "Money Lost", "Moves Aquired", "Moves Lost",
            "Points Aquired", "Points Lost", "Wanted Level Inc."
        };

        private Char[] trimNumChar = { ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
        private Char[] trimStringChar = { 'N', 'S', 'E', 'W' };

        #endregion

        #region Initializing

        public MapForm(ConnectForm conForm)
        {
            InitializeComponent();
            conFormRef = conForm;
            mapDBMultiLayerDoc = new Document(dataBasePainter.ImageDimX, dataBasePainter.ImageDimY);
            dataBasePainter.MapDBMultiLayerDocOneTimeLoader(ref mapDBMultiLayerDoc);
            new Thread(new ParameterizedThreadStart(NextClassExecute)).Start("0");
            MapStatusStripMoney.Text = "$" + ConnectForm.MoneyValue;
            CLActionCBx.Text = CLActionCBx.Items[0].ToString();
            MapDBContainer.HScrollBarXMax = ConnectForm.MapDataBase.GetLength(0) * 2
                * dataBasePainter.XLengthField - 137 - MapDBContainer.ScrollBarVertical_Width;
            MapDBContainer.VScrollBarYMax = ConnectForm.MapDataBase.GetLength(0) * 2
                * dataBasePainter.YLengthField - 93 - MapDBContainer.ScrollBarHorizontal_Height;
            this.Text = "Move Control " + ConnectForm.loginww;
        }

        #endregion

        #region Move Direction
        /// <summary>
        /// Move direction buttons executing void
        /// </summary>
        /// <param name="sender">The button parameters ovject</param>
        /// <param name="e">Arguments passed</param>
        private void WarfieldObtain_Click(object sender, EventArgs e)
        {
            if (((Button)sender).Text == "Execute")
            {
                new Thread(new ParameterizedThreadStart(NextClassExecute)).Start(CLActionCBx.Text);
            }
            else
            {
                new Thread(new ParameterizedThreadStart(NextClassExecute)).Start(((Button)sender).Text);
            }
        }

        /// <summary>
        /// The real action on move direction button click executor
        /// </summary>
        /// <param name="dataToSendReceived"></param>
        private void NextClassExecute(object dataToSendReceived)
        {
            String dataToSend = (String)dataToSendReceived;
            List<String> directionList = wwVmapDetails.ActionChecker(dataToSend);
            String sourcePageString = wwVmapDetails.GetPage(directionList[1]);
            wwVmapDetails.CreateHtml(sourcePageString);
            List<String> currentMapData = wwVmapDetails.CurrentMapData(sourcePageString);
            if (currentMapData[0] != "n/a")
            {
                mdbLoc[0] = currentMapData[0].TrimStart(trimNumChar).Substring(0, 1) +
                        currentMapData[0].Substring(currentMapData[0].Length - 1, 1);
                String tempXYLoc = String.Empty;
                tempXYLoc = currentMapData[0];
                for (int i = 0; i < trimStringChar.Length; i++)
                {
                    tempXYLoc = tempXYLoc.Replace(trimStringChar[i].ToString(), "");
                }
                int sLoc = tempXYLoc.IndexOf(' ');
                mdbLoc[1] = tempXYLoc.Substring(sLoc + 1, tempXYLoc.Length - sLoc - 1);
                mdbLoc[2] = tempXYLoc.Substring(0, sLoc);
            }
            if (directionList[0] == "False")
            {
                DataToFormSetI(wwVmapDetails.CurrentMapPosition(sourcePageString),
                    currentMapData);
            }
            else
            {
                DataToFormSetAdditionalI(wwVmapDetails.DoubleReadAction(sourcePageString));
            }
        }

        #endregion

        #region Mouse Map Hover

        /// <summary>
        /// Handling the event on mouse hover on map, showing hovered location
        /// certain data
        /// </summary>
        /// <param name="mouseLoc">Mouse location</param>
        /// <param name="OffsetX"></param>
        /// <param name="OffsetY"></param>
        /// <returns></returns>
        private String MapDBContainerMouseHover(Point mouseLoc)
        {
            String hoverLocData = String.Empty;
            hoverLocData = dataBasePainter.MapDBHoverLocation(mouseLoc,
                MapDBContainer.HScrollBarXVal, MapDBContainer.VScrollBarYVal, MapDBContainer.Width, MapDBContainer.Height);
            return hoverLocData;
        }

        private void MapDBContainer_MouseMove(object sender, MouseEventArgs e)
        {
            if (MapDBContainer.Image != null)
            {
                //Instantation
                HoverLocData hoverLocData = MapDBContainerMouseHover;
                //Receiving data
                IAsyncResult hLocData = hoverLocData.BeginInvoke(e.Location,
                null, null);
                HLLab.Text = hoverLocData.EndInvoke(hLocData);
            }
        }

        #endregion

        #region Mouse Click

        private void MapDBContainer_MouseClick(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                MouseClickLoc mouseClickLoc = MapDBContainerMouseClick;
                IAsyncResult mouseLocData = mouseClickLoc.BeginInvoke(e.Location,
                    MapDBContainer.HScrollBarXVal, MapDBContainer.VScrollBarYVal,
                    null, null);
                MapDBContainer.Image = mouseClickLoc.EndInvoke(mouseLocData);
            }
        }

        private Image MapDBContainerMouseClick(Point mouseLoc, int mapDBHScroll,
            int mapDBVScroll)
        {
            mapDBMultiLayerDoc.Layers[2] = dataBasePainter.MapDBFieldSelector(mouseLoc,
               mapDBHScroll, mapDBVScroll, ref mapDBFieldSelectedList,
               (BitmapLayer)mapDBMultiLayerDoc.Layers[2]);
            Image mapDBAllLayer = dataBasePainter.MapDBImageMerged(mapDBMultiLayerDoc);
            return mapDBAllLayer;
        }

        #endregion

        #region Field Parameters Setting

        /// <summary>
        /// Common data on form set invoker
        /// </summary>
        /// <param name="location"></param>
        /// <param name="mapData"></param>
        private void DataToFormSetI(String location, List<String> mapData)
        {
            if (CLLabD.InvokeRequired)
            {
                SetMapDataCallback dataSetClb = new SetMapDataCallback(DataToFormSetI);
                Invoke(dataSetClb, new object[] { location, mapData });
            }
            else
            {
                CLLabD.Text = location;
                String mapNo = String.Empty;
                int[] xyCoord = new int[2];
                pathExecutor.CoordinatesResolver(MapStatusStripLocation.Text, ref mapNo, ref xyCoord[1], ref xyCoord[0]);
                dataBasePainter.MapDBFieldLocationInv(mapNo, ref xyCoord[0], ref xyCoord[1]);
                oldRealLoc = (int[])xyCoord.Clone();
                MapStatusStripLocation.Text = "Location: " + location + " (" + mapData[0] + ")";
                MapStatusStripMoves.Text = "Moves: " + mapData[1];
                MapStatusStripTransport.Text = "Transport: " + mapData[2];
                dataBasePainter.MapDBLoadH = dataBasePainter.MapDBLoadState(mdbLoc[0],
                    int.Parse(mdbLoc[1]), int.Parse(mdbLoc[2]),
                    MapDBContainer.MapMiniLocX, MapDBContainer.MapMiniLocY);
                dataBasePainter.MapDBLoadV = dataBasePainter.MapDBLoadH;
                if (MapDBContainerWorker.IsBusy == true)
                {
                    MapDBContainerWorker.CancelAsync();
                }
                this.MapDBContainerWorker.RunWorkerAsync(new Boolean[] { dataBasePainter.MapDBLoadH, true, true, true });
                DataToFormSet(mapData);
            }
        }

        /// <summary>
        /// Common data on form set executor
        /// </summary>
        /// <param name="mapData"></param>
        private void DataToFormSet(List<String> mapData)
        {
            CLActionCBx.Enabled = true;
            CLActionCBx.Items.Clear();
            CLAdditionalText.Text = String.Empty;
            CLAdditionalText2.Text = String.Empty;
            for (int i = 0; i < mapData.Count; i++)
            {
                mapData[i] = mapData[i].Replace("Only", " ");
                if (mapData[i] == "no actions ")
                {
                    CLActionBt.Enabled = false;
                    break;
                }
                else if (mapData[i] == "Search Mountains")
                {
                    CLActionBt.Enabled = true;
                    CLActionCBx.Items.Add("Search");
                    break;
                }
                else if (mapData[i] == "Search Base")
                {
                    CLActionBt.Enabled = true;
                    CLActionCBx.Items.Add("Search Base");
                    break;
                }
                else if (mapData[i] == "Spy ")
                {
                    CLActionBt.Enabled = true;
                    CLActionCBx.Items.Add("Spy");
                    CLActionCBx.Items.Add("Attack");
                    CLAdditionalText.Text = "Base owned by:";
                    CLAdditionalText2.Text = mapData[5].Replace("base ", "");
                    break;
                }
                else if (mapData[i].Contains("Fortification"))
                {
                    CLActionBt.Enabled = true;
                    MoneyPriceResolve(mapData[i]);
                    break;
                }
                else if (mapData[i].Contains("Strength"))
                {
                    CLActionBt.Enabled = true;
                    MoneyPriceResolve(mapData[i]);
                    break;
                }
                else if (mapData[i].Contains("Security"))
                {
                    CLActionBt.Enabled = true;
                    MoneyPriceResolve(mapData[i]);
                    break;
                }
                else if (mapData[i].Contains("Transport"))
                {
                    CLActionBt.Enabled = true;
                    MoneyPriceResolve(mapData[i]);
                    break;
                }
                else if (mapData[i].Contains("Stealth"))
                {
                    CLActionBt.Enabled = true;
                    MoneyPriceResolve(mapData[i]);
                    break;
                }
            }
            if (CLActionCBx.Items.Count > 0)
            {
                CLActionCBx.Text = CLActionCBx.Items[0].ToString();
            }
            else
            {
                CLActionCBx.Items.Add("no actions");
                CLActionCBx.Text = CLActionCBx.Items[0].ToString();
                CLActionBt.Enabled = false;
            }
        }

        /// <summary>
        /// "Second Pass" Data to form set invoker (like if its about buying something)
        /// </summary>
        /// <param name="mapDataAddi"></param>
        private void DataToFormSetAdditionalI(List<String> mapDataAddi)
        {
            if (CLLabD.InvokeRequired)
            {
                SetMapDataAdditionalCallback dataSetAddiClb =
                    new SetMapDataAdditionalCallback(DataToFormSetAdditional);
                Invoke(dataSetAddiClb, new object[] { mapDataAddi });
            }
            else
            {
                DataToFormSetAdditional(mapDataAddi);
            }
        }

        /// <summary>
        /// "Second Pass" Data to form set executor
        /// </summary>
        /// <param name="mapDataAddi"></param>
        private void DataToFormSetAdditional(List<String> mapDataAddi)
        {
            CLAdditionalText.Text = String.Empty;
            CLAdditionalText2.Text = String.Empty;
            for (int i = 0; i < mapDataAddi.Count - 1; i++)
            {
                if (mapDataAddi[i] != "0")
                {
                    CLAdditionalText.Text += additionalDataStr[i] + ", ";
                    CLAdditionalText2.Text += mapDataAddi[i] + ", ";
                }
            }
            if (mapDataAddi[mapDataAddi.Count - 1] != "0")
            {
                CLAdditionalText.Text = "Spy Stats";
            }
        }

        /// <summary>
        /// The item price resolver (eg. when buying smth)
        /// </summary>
        /// <param name="inputData"></param>
        private void MoneyPriceResolve(String inputData)
        {
            int dSign = inputData.IndexOf('$');
            int sSign = inputData.IndexOf(' ');
            String tItem = inputData.Substring(sSign + 1, dSign - sSign - 1);
            tItem = Regex.Replace(tItem, "(?<first>[a-z0-9]|[A-Z])(?<second>[A-Z\\(])", "${first} ${second}");
            CLActionCBx.Items.Add("Upgrade");
            CLAdditionalText.Text = tItem;
            CLAdditionalText2.Text = inputData.Substring(dSign, inputData.Length - dSign);
        }

        #endregion

        #region HV Handler

        /// <summary>
        /// On horizontal scroll move event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void MapDBContainer_HScrollBar_ScrollEvent(object sender, ScrollEventArgs e)
        {
            dataBasePainter.HSCBarState = true;
            if (Math.Abs(e.OldValue - e.NewValue) >= dataBasePainter.XLengthField)
            {
                if (MapDBContainerWorker.IsBusy == false)
                {
                    int dbNum = 0;
                    int hSCBarValue = e.NewValue;
                    int vSCBarValue = MapDBContainer.VScrollBarYVal;
                    hSCBarValue = hSCBarValue / dataBasePainter.XLengthField;
                    vSCBarValue = vSCBarValue / dataBasePainter.YLengthField + 5;
                    dataBasePainter.MapDBFieldLocation(ref dbNum, ref hSCBarValue, ref vSCBarValue);
                    mdbLoc[0] = dataBasePainter.MapDBNameFromIntEval(dbNum);
                    mdbLoc[1] = hSCBarValue.ToString();
                    mdbLoc[2] = vSCBarValue.ToString();
                    dataBasePainter.MapDBLoadH = dataBasePainter.MapDBLoadState(mdbLoc[0], int.Parse(mdbLoc[1]),
                        int.Parse(mdbLoc[2]), MapDBContainer.MapMiniLocX, MapDBContainer.MapMiniLocY);
                    this.MapDBContainerWorker.RunWorkerAsync(new Boolean[] { dataBasePainter.MapDBLoadH, false, true, dataBasePainter.VSCBarState });
                    Invalidate();
                }
            }
            label1.Text = MapDBContainer.HScrollBarXVal.ToString() + "|" + MapDBContainer.MapMiniLocX.ToString();
            label2.Text = MapDBContainer.VScrollBarYVal.ToString() + "|" + MapDBContainer.MapMiniLocY.ToString();
        }

        /// <summary>
        /// On vertical scroll move event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void MapDBContainer_VScrollBar_ScrollEvent(object sender, ScrollEventArgs e)
        {
            dataBasePainter.VSCBarState = true;
            if (Math.Abs(e.OldValue - e.NewValue) >= dataBasePainter.YLengthField)
            {
                if (MapDBContainerWorker.IsBusy == false)
                {
                    int dbNum = 0;
                    int hSCBarValue = MapDBContainer.HScrollBarXVal;
                    int vSCBarValue = e.NewValue;
                    hSCBarValue = hSCBarValue / dataBasePainter.XLengthField + 7;
                    vSCBarValue = vSCBarValue / dataBasePainter.YLengthField;
                    dataBasePainter.MapDBFieldLocation(ref dbNum, ref hSCBarValue, ref vSCBarValue);
                    mdbLoc[0] = dataBasePainter.MapDBNameFromIntEval(dbNum);
                    mdbLoc[1] = hSCBarValue.ToString();
                    mdbLoc[2] = vSCBarValue.ToString();
                    dataBasePainter.MapDBLoadV = dataBasePainter.MapDBLoadState(mdbLoc[0], int.Parse(mdbLoc[1]),
                        int.Parse(mdbLoc[2]), MapDBContainer.MapMiniLocX, MapDBContainer.MapMiniLocY);
                    this.MapDBContainerWorker.RunWorkerAsync(new Boolean[] { dataBasePainter.MapDBLoadV, false, dataBasePainter.HSCBarState, true });
                    Invalidate();
                }
            }
            label1.Text = MapDBContainer.HScrollBarXVal.ToString() + "|" + MapDBContainer.MapMiniLocX.ToString();
            label2.Text = MapDBContainer.VScrollBarYVal.ToString() + "|" + MapDBContainer.MapMiniLocY.ToString();
        }

        /// <summary>
        /// Sets data acquired by bg worker to specific values (eg. hOffset, hScrollBar, minimapLocX|Y)
        /// </summary>
        /// <param name="offsetX"></param>
        /// <param name="hScroll"></param>
        /// <param name="mapMiniLocX"></param>
        /// <param name="mapMiniLocY"></param>
        private void MapDBHorizontalDataSet(int offsetX, int hScroll, int mapMiniLocX, int mapMiniLocY)
        {
            if (MapDBContainer.InvokeRequired)
            {
                MapDBSCBarsRelocator mapDBSCBarR = new MapDBSCBarsRelocator(MapDBHorizontalDataSet);
                Invoke(mapDBSCBarR, new object[] { offsetX, hScroll, mapMiniLocX, mapMiniLocY });
            }
            else
            {
                MapDBContainer.OffsetX = offsetX;
                MapDBContainer.HScrollBarXVal = hScroll;
                if (mapMiniLocX >= 0)
                {
                    MapDBContainer.MapMiniLocX = mapMiniLocX;
                }
                if (mapMiniLocY >= 0)
                {
                    MapDBContainer.MapMiniLocY = mapMiniLocY;
                }
            }
        }

        /// <summary>
        /// Sets data acquired by bg worker to specific values (eg. vOffset, vScrollbar, minimapLocY|X
        /// </summary>
        /// <param name="offsetY"></param>
        /// <param name="vScroll"></param>
        /// <param name="mapMiniLocY"></param>
        /// <param name="mapMiniLocX"></param>
        private void MapDBVerticalDataSet(int offsetY, int vScroll, int mapMiniLocY, int mapMiniLocX)
        {
            if (MapDBContainer.InvokeRequired)
            {
                MapDBSCBarsRelocator mapDBSCBarR = new MapDBSCBarsRelocator(MapDBVerticalDataSet);
                Invoke(mapDBSCBarR, new object[] { offsetY, vScroll, mapMiniLocY, mapMiniLocX });
            }
            else
            {
                MapDBContainer.OffsetY = offsetY;
                MapDBContainer.VScrollBarYVal = vScroll;
                if (mapMiniLocX >= 0)
                {
                    MapDBContainer.MapMiniLocX = mapMiniLocX;
                }
                if (mapMiniLocY >= 0)
                {
                    MapDBContainer.MapMiniLocY = mapMiniLocY;
                }
            }
        }


        #endregion

        #region Map Loader Worker

        /// <summary>
        /// Map asynchronous loading stuff - first executing void
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void mapDBContainerWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            if (MapDBContainerWorker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
            String[] mapLoc = (String[])mdbLoc.Clone();
            Boolean[] mapLoadState = (Boolean[])e.Argument;
            if (mapLoadState[0] == true)
            {
                mdbCenter = (String[])mapLoc.Clone();
                mapDBMultiLayerDoc.Layers[0] = dataBasePainter.MapDBLayerConverter(dataBasePainter.MapDBContainerLoading(mdbCenter));
                mapDBMultiLayerDoc.Layers[2] = dataBasePainter.MapDBFieldOnMapLoad(mapDBFieldSelectedList, mdbCenter);
                oldXYLoc = new int[2];
            }
            if (mapLoadState[1] == true)
            {
                mapDBMultiLayerDoc.Layers[1] = dataBasePainter.MapDBLayerConverter(dataBasePainter.MapDBFieldUser(mapLoc[0],
                    int.Parse(mapLoc[1]), int.Parse(mapLoc[2]), ref hOffsetBarVal, ref vOffsetBarVal,
                    mapLoadState[0], oldRealLoc));
                Boolean assignState = false;
                int[] xzyCoordMDB = new int[3];
                String mapNoMDB = String.Empty;
                pathExecutor.CoordinatesResolver(MapStatusStripLocation.Text, ref mapNoMDB, ref xzyCoordMDB[2], ref xzyCoordMDB[0]);
                xzyCoordMDB[1] = dataBasePainter.MapDBNameFromStringEval(mapNoMDB);
                BitmapLayer mapDBTmpLayer = dataBasePainter.CurrentMapPositionEval((BitmapLayer)mapDBMultiLayerDoc.Layers[0],
                   CLLabD.Text, xzyCoordMDB, ref assignState);
                if (assignState == true)
                {
                    dataBaseHandler.WriteMapDataBaseMemory(CLLabD.Text, xzyCoordMDB);
                    mapDBMultiLayerDoc.Layers[0] = mapDBTmpLayer;
                }
                //put the mapLayerMap field refresher
            }

            //value of horizontal|vertical scbar
            if (mapLoadState[0] == true)
            {
                dataBasePainter.MapDBUserLocXYExec(mapLoc[0], int.Parse(mapLoc[1]),
                    int.Parse(mapLoc[2]), ref hOffsetBarVal, ref vOffsetBarVal);
                dataBasePainter.MapDBUserSCBarValExec(mapLoc[0], int.Parse(mapLoc[1]),
                    int.Parse(mapLoc[2]), ref hSCBarVal, ref vSCBarVal);
            }
            else if (mapLoadState[1] == true)
            {
                dataBasePainter.MapDBUserLocXYOrdinary(mapLoc[0], int.Parse(mapLoc[1]),
                    int.Parse(mapLoc[2]), oldRealLoc, ref hOffsetBarVal, ref vOffsetBarVal);
                dataBasePainter.MapDBUserLocXYOrdinary(mapLoc[0], int.Parse(mapLoc[1]),
                    int.Parse(mapLoc[2]), oldRealLoc, ref hSCBarVal, ref vSCBarVal);
            }
            oldXYLoc[0] = int.Parse(mapLoc[1]);
            oldXYLoc[1] = int.Parse(mapLoc[2]);
            Boolean[] eResult;
            if ((mapLoadState[0] == false) && (mapLoadState[1] == false))
            {
                eResult = new Boolean[] { false, false, false };
            }
            else
            {
                eResult = new Boolean[] { true, mapLoadState[2], mapLoadState[3] };
                if (mapLoadState[1] == false)
                {
                    Image emptyLayerImg = new Bitmap(dataBasePainter.ImageDimX,
                        dataBasePainter.ImageDimY);
                    mapDBMultiLayerDoc.Layers[1] = dataBasePainter.MapDBLayerConverter(emptyLayerImg);
                }
            }
            int[] tHResult = new int[4];
            int[] tVResult = new int[4];
            int[] cResult = new int[9];
            for (int j = 0; j < tHResult.Length; j++)
            {
                tHResult[j] = int.MinValue;
                tVResult[j] = int.MinValue;
            }
            for (int i = 0; i < cResult.Length; i++)
            {
                cResult[i] = int.MinValue;
            }
            if (eResult[0] == true)
            {
                cResult[0] = 1;         //load or not load state
                if (eResult[1] == true)
                {
                    cResult[1] = 1;     //horizontal load or not
                    tHResult = dataBasePainter.MapDBContainerHorizontalValueSettings(
                        hSCBarVal, vSCBarVal, hOffsetBarVal, MapDBContainer.OffsetX,
                        MapDBContainer.Size.Width, MapDBContainer.HScrollBarXMax,
                        MapDBContainer.VScrollBarYMax, MapDBContainer.HScrollBarXVal);
                }
                else
                {
                    cResult[1] = 0;
                }
                if (eResult[2] == true)
                {
                    cResult[2] = 1;     //vertical load or not
                    tVResult = dataBasePainter.MapDBContainerVerticalValueSettings(
                        vSCBarVal, hSCBarVal, vOffsetBarVal, MapDBContainer.OffsetY,
                        MapDBContainer.Size.Height, MapDBContainer.VScrollBarYMax,
                        MapDBContainer.HScrollBarXMax, MapDBContainer.VScrollBarYVal);
                }
                else
                {
                    cResult[2] = 0;
                }
                cResult[3] = tHResult[0];       //offsetX
                cResult[4] = tHResult[1];       //scroll horizontal
                cResult[5] = tHResult[2];       //map minilocX
                cResult[6] = tVResult[0];       //offsetY
                cResult[7] = tVResult[1];       //scroll vertical
                cResult[8] = tVResult[3];       //map miniLocY
                if (tVResult[3] == int.MinValue)
                {
                    if (tHResult[3] != int.MinValue)
                    {
                        cResult[8] = tHResult[3];
                    }
                    else
                    {
                        cResult[8] = MapDBContainer.MapMiniLocY;
                    }
                }
                if (tHResult[2] == int.MinValue)
                {
                    if (tVResult[2] != int.MinValue)
                    {
                        cResult[5] = tVResult[2];
                    }
                    else
                    {
                        cResult[5] = MapDBContainer.MapMiniLocX;
                    }
                }

            }
            else
            {
                cResult[0] = 0;
            }
            e.Result = cResult;
        }

        /// <summary>
        /// On asynchronous work completed method
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void mapDBContainerWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled)
            {
                MessageBox.Show("Map loading operation canceled!");
            }
            else if (e.Error != null)
            {
                MessageBox.Show("Error! " + e.Error.ToString());
            }
            else
            {
                int[] someSCBarsState = (int[])e.Result;
                if (someSCBarsState[0] == 1)
                {
                    MapDBContainer.Image = dataBasePainter.MapDBImageMerged(mapDBMultiLayerDoc);
                    if (someSCBarsState[2] == 1)
                    {
                        MapDBVerticalDataSet(someSCBarsState[6], someSCBarsState[7], someSCBarsState[8], someSCBarsState[5]);
                    }
                    if (someSCBarsState[1] == 1)
                    {
                        MapDBHorizontalDataSet(someSCBarsState[3], someSCBarsState[4], someSCBarsState[5], someSCBarsState[8]);
                    }
                }
            }
        }

        /// <summary>
        /// On progress changed method
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void mapDBContainerWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
        }

        #endregion

        #region Map Path Worker

        /// <summary>
        /// The main code worker executer.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MapDBLocWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            List<String> pathList = (List<String>)e.Argument;
            if (pathList.Count > 0)
            {
                String[] tmpStr = pathList[0].Split(".".ToCharArray());
                String moveDir = String.Empty;
                int xCoordO = 0;
                int yCoordO = 0;
                String mapNo = String.Empty;
                //resolves the coords from the string
                if (!MapStatusStripLocation.Text.Contains("n/a"))
                {
                    pathExecutor.CoordinatesResolver(MapStatusStripLocation.Text, ref mapNo, ref yCoordO, ref xCoordO);
                    dataBasePainter.MapDBFieldLocationInv(mapNo, ref xCoordO, ref yCoordO);
                    int xCoordN;
                    int yCoordN;
                    Boolean breakState = false;
                    for (int i = 0; i < pathList.Count; i++)
                    {
                        tmpStr = pathList[i].Split(".".ToCharArray());
                        xCoordN = int.Parse(tmpStr[0]);
                        yCoordN = int.Parse(tmpStr[1]);
                        xCoordO = xCoordN - xCoordO;
                        yCoordO = yCoordN - yCoordO;
                        if (xCoordO == 0)
                        {
                            moveDir = pathExecutor.DirectionMoveEx(yCoordO, 1);
                        }
                        else if (yCoordO == 0)
                        {
                            moveDir = pathExecutor.DirectionMoveEx(xCoordO, 0);
                        }
                        else
                        {
                            MessageBox.Show("Something is horribly wrong with the path !");
                            breakState = true;
                            break;
                        }
                        //execute the inner "move" - NextClass method
                        NextClassExecute(moveDir);
                        String action = pathExecutor.ActionsResolver(CLLabD.Text);
                        //execute action if the field is in executable field group (eg mountain)
                        if (action != String.Empty)
                        {
                            NextClassExecute(action);
                        }
                        //sets the map field if not visited before
                        //obtain the info if the move successed or not
                        xCoordO = xCoordN;
                        yCoordO = yCoordN;
                    }
                    if (breakState == false)
                    {
                        mapDBFieldSelectedList = new List<String>();
                        mapPathList = new List<String>();
                    }
                }
            }
        }

        /// <summary>
        /// On worker progress changed.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MapDBLocWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
        }

        /// <summary>
        /// Occurs when worker complete its work.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MapDBLocWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
        }

        #endregion

        #region SaveToFile Worker

        /// <summary>
        /// Handles "DoWork" event.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SaveToBaseWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            /*
            DEPRECATED - WRITES THE FOUR DATABASES TO FILE 
            THE NEW WILL WRITE TO THE COMPRESSED FILE
            while (!SaveToBaseWorker.CancellationPending)
            {
                for (int i = 0; i < 4; i++)
                {
                    dataBaseHandler.WriteMapDataBase(i);
                }
                Thread.Sleep(600000);   //10 minutes thread sleep
            }
            */
            while (!SaveToBaseWorker.CancellationPending)
            {
                //10 minutes thread sleep
                Thread.Sleep(600000);
                //dumps TOTAL base to a compressed file and makes backup !
                dataBaseHandler.DumpTheBase("." + ConnectForm.loginww);
            }
        }

        #endregion

        #region MovesDeterminer Worker

        /// <summary>
        /// Handles the process of move path creation
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MovesDeterminerWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            possibleMoves.SomePathList = mapDBFieldSelectedList;
            int[] eArgs = new int[4];
            eArgs[0] = (int)e.Argument;
            if (eArgs[0] != 0)
            {
                int xValueTmp = 0;
                int yValueTmp = 0;
                String mapNoTmp = String.Empty;
                pathExecutor.CoordinatesResolver(MapStatusStripLocation.Text, ref mapNoTmp, ref yValueTmp, ref xValueTmp);
                dataBasePainter.MapDBFieldLocationInv(mapNoTmp, ref xValueTmp, ref yValueTmp);
                eArgs[1] = xValueTmp;
                eArgs[2] = yValueTmp;
                int movesCtr = 0;
                int.TryParse(RunMovesTBx.Text, out movesCtr);
                if (movesCtr != 0)
                {
                    eArgs[3] = movesCtr;
                }
                else
                {
                    eArgs[3] = dataBasePainter.MovesResolver(MapStatusStripMoves.Text); //number of moves in path need to change !
                }
            }
            e.Result = possibleMoves.ListDeterminer(eArgs);
        }

        /// <summary>
        /// On complete worker event handler.. not much to say about it
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MovesDeterminerWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            mapDBFieldSelectedList = (List<String>)e.Result;
            mapPathList = mapDBFieldSelectedList;
            MapDBContainerWorker.RunWorkerAsync(new Boolean[] { true, true, true, true });
            MapDBLocWorker.RunWorkerAsync(mapPathList);
        }

        #endregion

        /// <summary>
        /// Saves the mapto file
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SaveBt_Click(object sender, EventArgs e)
        {
            dataBaseHandler.DumpTheBase();
        }

        /// <summary>
        /// Starts the validation path field list process
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CheckBt_Click(object sender, EventArgs e)
        {
            mapPathList = possibleMoves.MapPathValidator(mapDBFieldSelectedList);

        }

        /// <summary>
        /// Executes the move through the given path
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void RunPathBt_Click(object sender, EventArgs e)
        {
            if ((!MapDBLocWorker.IsBusy) && (!MovesDeterminerWorker.IsBusy))
            {
                if (RunCBX.SelectedIndex > -1)
                {
                    MovesDeterminerWorker.RunWorkerAsync(RunCBX.SelectedIndex);
                }
                else
                {
                    MessageBox.Show("Pick any path type to run !");
                }
            }
        }

        #region Form Internal Events

        /// <summary>
        /// On map shown event handler void
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MapForm_Shown(object sender, EventArgs e)
        {
            SaveToBaseWorker.RunWorkerAsync();
        }

        /// <summary>
        /// Handles the form closing event.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MapForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            SaveToBaseWorker.CancelAsync();
        }

        #endregion

        private void button1_Click(object sender, EventArgs e)
        {
            ConFormRef.IconChange(int.Parse(textBox1.Text));
        }

    }
}