rendered paste bodyusing 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));
}
}
}