public async Task InsertLayerAsync_InsertsLayerCorrectly()
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedLayerList = (cnn.Query <MapLayerItem>($"SELECT * FROM Layer WHERE Id={insertedLayer.Id}")).ToList();
Assert.AreEqual(1, queriedLayerList.Count, $@"Database query for inserted layer returned list with number of entries
different than one.
Expected: 1,
Actual: {queriedLayerList.Count}.");
var queriedLayer = queriedLayerList.First();
Assert.IsNotNull(queriedLayer, "Database query for inserted layer returned null.");
Assert.AreEqual(insertedLayer.Id, queriedLayer.Id, $@"Database query for inserted layer returned layer with differrent Id.
Expected: {insertedLayer.Id},
Actual: {queriedLayer.Id}.");
Assert.AreEqual(insertedLayer.Name, queriedLayer.Name, $@"Database query for inserted layer returned layer with different Name.
Expected: {insertedLayer.Name},
Actual: {queriedLayer.Name}.");
}
}
public override IExplorerNode Creat(object sender, Models.Generic.IExplorerItem item_attribute)
{
var model = sender as IBasicModel;
var root_menu = ContextMenuFactory.Creat(item_attribute);
root_mapdata = new Node("Map Coverage")
{
Image = Resources.DataFrame16,
Tag = root_menu
};
model.Project.FeatureCoverages.CollectionChanged += LayerParameters_CollectionChanged;
model.Project.RasterLayerCoverages.CollectionChanged += LayerParameters_CollectionChanged;
foreach (var lp in model.Project.FeatureCoverages)
{
MapLayerItem layer_item = new MapLayerItem();
layer_item.Coverage = lp;
var creator = NodeFactory.Select(layer_item);
var layer_node = creator.Creat(model, layer_item) as Node;
root_mapdata.Nodes.Add(layer_node);
}
foreach (var lp in model.Project.RasterLayerCoverages)
{
MapLayerItem layer_item = new MapLayerItem();
layer_item.Coverage = lp;
var creator = NodeFactory.Select(layer_item);
var layer_node = creator.Creat(model, layer_item) as Node;
root_mapdata.Nodes.Add(layer_node);
}
return(root_mapdata);
}
private void UpdateMapLayerItems()
{
ObservableCollection <LayerItemViewModel> mapLayerItems = new ObservableCollection <LayerItemViewModel>();
foreach (Layer layer in GetLayers(LayerIDs, Map))
{
if (layer.ShowLegend)
{
MapLayerItem mapLayerItem = FindMapLayerItem(layer);
if (mapLayerItem == null) // else reuse existing map layer item to avoid query again the legend and to keep the current state (selected, expansed, ..)
{
// Create a new map layer item
mapLayerItem = new MapLayerItem(layer)
{
LegendTree = this, LayerItemsOptions = LegendTree.LayerItemsOptions
};
mapLayerItem.Refresh();
}
mapLayerItems.Add(mapLayerItem);
}
}
LayerItems = mapLayerItems;
}
public async Task GetLayersAsync_ReturnLayerListCorrectly()
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
var returnedList = await DatabaseAccessService.GetLayersAsync();
Assert.IsNotNull(returnedList, "Returned object is null");
Assert.AreEqual(1, returnedList.Count, $@"Returned list count is wrong.
Expected: {1},
Actual: {returnedList.Count}.");
var returnedLayer = returnedList.First();
Assert.IsNotNull(returnedLayer, "Database query for inserted layer returned null.");
Assert.AreEqual(insertedLayer.Id, returnedLayer.Id, $@"Database query for inserted layer returned layer with differrent Id.
Expected: {insertedLayer.Id},
Actual: {returnedLayer.Id}.");
Assert.AreEqual(insertedLayer.Name, returnedLayer.Name, $@"Database query for inserted layer returned layer with different Name.
Expected: {insertedLayer.Name},
Actual: {returnedLayer.Name}.");
}
public async Task DeleteMapElementAsync_DeletesMapElementCorrectly()
{
var taskSource = new TaskCompletionSource <object>();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
try
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
var path = new List <BasicGeoposition>()
{
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
new BasicGeoposition()
{
Latitude = 3, Longitude = 4
},
new BasicGeoposition()
{
Latitude = 6, Longitude = 2
}
};
var insertedPolygon = MapElementItemFactoryService.GetMapPolygonItem("Test polygon", path,
insertedLayer, Color.FromArgb(0, 0, 0, 0), Color.FromArgb(0, 0, 0, 0));
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
await DatabaseAccessService.InsertMapPolygonItemAsync(insertedPolygon);
await DatabaseAccessService.DeleteMapElementAsync(insertedPolygon.Id);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedMapElementList = await DatabaseAccessService.GetMapElementItemsAsync();
Assert.AreEqual(0, queriedMapElementList.Count, $@"Database query for inserted MapElement
returned list with number of entries different than zero.
Expected: 0,
Actual: {queriedMapElementList.Count}.");
}
taskSource.SetResult(null);
}
catch (Exception e)
{
taskSource.SetException(e);
}
});
await taskSource.Task;
}
/// <summary>
/// Initializes a new instance of the AddButtonClickedEventArgs class.
/// </summary>
/// <param name="name">Name of the added map element.</param>
/// <param name="border">Border (stroke) color of the added map element.</param>
/// <param name="fill">Fill color of the added map element.</param>
/// <param name="layer">Layer of the added map element.</param>
/// <param name="width">Width of the added map element.</param>
public AddButtonClickedEventArgs(string name, Color border, Color fill, MapLayerItem layer, double width)
{
Name = name;
BorderColor = border;
FillColor = fill;
Layer = layer;
Width = width;
}
/// <summary>
/// Inserts a new layer into the database
/// </summary>
/// <param name="layer">Object containing porperties to be inserted into the database.</param>
public static async Task InsertLayerAsync(MapLayerItem layer)
{
using (var cnn = await GetDbConnectionAsync())
{
cnn.Open();
await cnn.ExecuteScalarAsync <int>(
@"INSERT INTO Layer (Id, Name) VALUES (@Id, @Name)",
layer);
}
}
public void FreshMapGrid()
{
mapGird.Clear();
int index = layers.IndexOf(MapEditorSortLayer.Floor1);
if (index != -1)
{
MapLayerItem mapLayerItem = layerItems[index];
for (int i = 0; i < mapLayerItem.items.Count; i++)
{
mapGird.Add(mapLayerItem.posList[i], mapLayerItem.items[i]);
}
}
}
/// <summary>
/// Creates a new instance of MapPolylineItem class.
/// </summary>
/// <param name="id"></param>
/// <param name="name"></param>
/// <param name="width"></param>
/// <param name="length"></param>
/// <param name="polygonRepresentationPath"></param>
/// <param name="path"></param>
/// <param name="layer"></param>
/// <param name="strokeColor"></param>
/// <returns></returns>
public static MapPolylineItem GetMapPolylineItem(int id,
string name,
double width,
double length,
IReadOnlyList <BasicGeoposition> polygonRepresentationPath,
IReadOnlyList <BasicGeoposition> path,
MapLayerItem layer,
Color strokeColor)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Name cannot be empty", nameof(name));
}
if (polygonRepresentationPath is null)
{
throw new ArgumentNullException(nameof(polygonRepresentationPath));
}
if (path is null)
{
throw new ArgumentNullException(nameof(path));
}
if (layer is null)
{
throw new ArgumentNullException(nameof(layer));
}
MapPolylineItem result = new MapPolylineItem()
{
Id = id,
ParentLayer = layer,
Name = name,
Length = length,
Width = width,
Path = path
};
MapPolygon element = new MapPolygon()
{
FillColor = strokeColor,
StrokeColor = strokeColor,
ZIndex = layer.Id
};
element.Paths.Add(new Geopath(polygonRepresentationPath));
result.Element = element;
return(result);
}
/// <summary>
/// Creates a new instance of MapPolylineItem class. Calculates incomplete data.
/// </summary>
/// <param name="name"></param>
/// <param name="path"></param>
/// <param name="layer"></param>
/// <param name="strokeColor"></param>
/// <param name="width"></param>
/// <param name="id"></param>
/// <returns></returns>
public static MapPolylineItem GetMapPolylineItem(string name, IReadOnlyList <BasicGeoposition> path,
MapLayerItem layer, Color strokeColor, double width,
int id = -1)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Name cannot be empty", nameof(name));
}
if (path is null)
{
throw new ArgumentNullException(nameof(path));
}
if (layer is null)
{
throw new ArgumentNullException(nameof(layer));
}
List <BasicGeoposition> left = new List <BasicGeoposition>();
List <BasicGeoposition> right = new List <BasicGeoposition>();
for (int i = 0; i < path.Count - 1; i++)
{
BasicGeoposition z = new BasicGeoposition()
{
Altitude = 1
};
BasicGeoposition vec = GeoMath.Difference(path[i + 1], path[i]);
BasicGeoposition prod = GeoMath.CrossProduct(vec, z);
BasicGeoposition norm = GeoMath.Normalize(prod);
BasicGeoposition tim = GeoMath.TimesScalar(norm, width);
right.Add(GeoMath.Sum(path[i], tim));
right.Add(GeoMath.Sum(path[i + 1], tim));
BasicGeoposition neg = GeoMath.TimesScalar(tim, -1);
left.Insert(0, GeoMath.Sum(path[i], neg));
left.Insert(0, GeoMath.Sum(path[i + 1], neg));
}
left.InsertRange(left.Count, right);
return(GetMapPolylineItem(id,
name,
width,
GeoMath.PolylineLength(path),
left,
path,
layer,
strokeColor));
}
void ClearStoneWallAndEdge()
{
for (int i = 0; i < currMapScene.layerItems.Count; i++)
{
MapLayerItem mapLayerItem = currMapScene.layerItems[i];
for (int j = mapLayerItem.items.Count - 1; j >= 0; j--)
{
if (mapLayerItem.items[j].itemType == MapEditorItemType.StoneWall)
{
mapLayerItem.items[j] = mapLayerItem.items[j].replaceItem;
}
else if (mapLayerItem.items[j].itemType == MapEditorItemType.Edge)
{
mapLayerItem.items.RemoveAt(j);
mapLayerItem.posList.RemoveAt(j);
}
}
}
}
public void GetMapIconItem_ConstructsMapIconItemCorrectly()
{
var expectName = "TestName";
var expectPosition = new BasicGeoposition()
{
Latitude = 1, Longitude = 2
};
var expectLayer = new MapLayerItem()
{
Id = 3, Name = "TestLayer"
};
int expectId = 4;
var icon = MapElementItemFactoryService.GetMapIconItem(expectName, expectPosition, expectLayer, expectId);
Assert.AreEqual(expectName, icon.Name);
Assert.AreEqual(expectPosition, icon.GetPosition());
Assert.AreEqual(expectLayer, icon.ParentLayer);
Assert.AreEqual(expectId, icon.Id);
}
private void LayerParameters_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
var lp = e.NewItems[0] as PackageCoverage;
MapLayerItem layer_item = new MapLayerItem();
layer_item.Coverage = lp;
var creator = NodeFactory.Select(layer_item);
var layer_node = creator.Creat(sender, layer_item) as Node;
root_mapdata.Nodes.Add(layer_node);
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
var lp = e.OldItems[0];// as IFeatureLayerMapping;
var node = from nn in root_mapdata.Nodes where (nn.Tag as MapLayerContextMenu).Coverage.Equals(lp) select nn;
if (node.Count() == 1)
{
root_mapdata.Nodes.Remove(node.First());
}
}
}
public void GetMapPolygonItem_ConstructMapPolygonItemCorrectly()
{
var expectName = "TestName";
var expectPath = new List <BasicGeoposition>()
{
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
new BasicGeoposition()
{
Latitude = 2, Longitude = 3
},
new BasicGeoposition()
{
Latitude = 3, Longitude = 4
}
};
var expectLayer = new MapLayerItem()
{
Id = 3, Name = "TestLayer"
};
int expectId = 5;
var expectStrokeColor = Color.FromArgb(100, 100, 100, 100);
var expectFillColor = Color.FromArgb(2, 2, 2, 2);
var polygon = MapElementItemFactoryService.GetMapPolygonItem(
expectName, expectPath, expectLayer, expectStrokeColor, expectFillColor, expectId);
Assert.AreEqual(expectName, polygon.Name);
Assert.AreEqual(expectLayer, polygon.ParentLayer);
Assert.AreEqual(expectId, polygon.Id);
Assert.AreEqual(expectStrokeColor, polygon.StrokeColor);
Assert.AreEqual(expectFillColor, polygon.FillColor);
Assert.IsTrue(expectPath.SequenceEqual(polygon.Path));
}
private void UpdateMapLayerItems()
{
ObservableCollection<LayerItemViewModel> mapLayerItems = new ObservableCollection<LayerItemViewModel>();
foreach (Layer layer in GetLayers(LayerIDs, Map))
{
MapLayerItem mapLayerItem = FindMapLayerItem(layer);
if (mapLayerItem == null) // else reuse existing map layer item to avoid query again the legend and to keep the current state (selected, expansed, ..)
{
// Create a new map layer item
mapLayerItem = new MapLayerItem(layer) {LegendTree = this};
mapLayerItem.Refresh();
}
mapLayerItems.Add(mapLayerItem);
}
LayerItems = mapLayerItems;
}
/// <summary>
/// Creates a new instance of MapIconItem class.
/// </summary>
/// <param name="name"></param>
/// <param name="position"></param>
/// <param name="layer"></param>
/// <param name="id"></param>
/// <returns></returns>
public static MapIconItem GetMapIconItem(string name, BasicGeoposition position, MapLayerItem layer, int id = -1)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Name cannot be empty", nameof(name));
}
if (layer is null)
{
throw new ArgumentNullException(nameof(layer));
}
return(new MapIconItem()
{
Element = new MapIcon()
{
NormalizedAnchorPoint = new Point(0.5, 1.0),
Image = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/map.png")),
Location = new Geopoint(position),
Title = name,
ZIndex = layer.Id
},
Name = name,
ParentLayer = layer,
Id = id
});
}
/// <summary>
/// Creates a new instance of MapPolygonItem class.
/// </summary>
/// <param name="name"></param>
/// <param name="path"></param>
/// <param name="layer"></param>
/// <param name="strokeColor"></param>
/// <param name="fillColor"></param>
/// <param name="id"></param>
/// <returns></returns>
public static MapPolygonItem GetMapPolygonItem(string name, IReadOnlyList <BasicGeoposition> path, MapLayerItem layer, Color strokeColor, Color fillColor, int id = -1)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Name cannot be empty", nameof(name));
}
if (path is null)
{
throw new ArgumentNullException(nameof(path));
}
if (layer is null)
{
throw new ArgumentNullException(nameof(layer));
}
var polygon = new MapPolygon()
{
FillColor = fillColor,
StrokeColor = strokeColor,
ZIndex = layer.Id
};
polygon.Paths.Add(new Geopath(path));
return(new MapPolygonItem()
{
Id = id,
Name = name,
ParentLayer = layer,
Element = polygon,
BorderLength = GeoMath.PolygonBorderLength(path)
});
}
public void UpdateMap()
{
rects.Clear();
m_triangles.Clear();
m_uv.Clear();
posList.Clear();
m_vertices.Clear();
offsetList.Clear();
int count = generatePrefabItems.Count;
for (int i = 0; i < count; i++)
{
GameObject.DestroyImmediate(generatePrefabItems[i]);
}
generatePrefabItems.Clear();
for (int i = 0; i < 3; i++)
{
int index = layers.IndexOf((MapEditorSortLayer)i);
if (index != -1)
{
MapLayerItem mapLayerItem = layerItems[index];
count = mapLayerItem.items.Count;
for (int j = 0; j < count; j++)
{
int x = mapLayerItem.posList[j] / 10000;
int y = mapLayerItem.posList[j] % 10000;
if (mapLayerItem.items[j].isPrefab)
{
GameObject go = GameObject.Instantiate(mapLayerItem.items[j].gameObject);
go.transform.position = MapManager.GetPos(x + offsetX, y + offsetY);
generatePrefabItems.Add(go);
}
else
{
List <MapSprite> list = new List <MapSprite>();
if (mapLayerItem.items[j].isNine)
{
list = GetSpriteList(x, y, mapGird);
}
else
{
list = mapLayerItem.items[j].normalList;
}
int random = Random.Range(0, 10000);
MapSprite mapSprite = list.Where(s => random < s.sRate).FirstOrDefault();
rects.Add(mapSprite.sprite.rect);
posList.Add(new Vector2((x + offsetX) * MapManager.textSize + MapManager.textSize / 2.0f, (y + offsetY) * MapManager.textSize + MapManager.textSize / 2.0f));
offsetList.Add(new Vector2(mapSprite.offsetX, mapSprite.offsetY) * MapManager.textSize * 0.05f);
}
}
}
}
if (Application.isPlaying)
{
CombineMesh();
}
else
{
#if UNITY_EDITOR
CombineMeshFromEditor();
#endif
}
}
public async Task GetMapElementItemsAsync_ReturnsMapElementListCorrectly()
{
var taskSource = new TaskCompletionSource <object>();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
try
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
var path = new List <BasicGeoposition>()
{
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
new BasicGeoposition()
{
Latitude = 3, Longitude = 4
},
new BasicGeoposition()
{
Latitude = 6, Longitude = 2
}
};
var insertedPolygon = MapElementItemFactoryService.GetMapPolygonItem("Test polygon", path,
insertedLayer, Color.FromArgb(0, 0, 0, 0), Color.FromArgb(0, 0, 0, 0));
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
await DatabaseAccessService.InsertMapPolygonItemAsync(insertedPolygon);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedMapElementList = await DatabaseAccessService.GetMapElementItemsAsync();
Assert.AreEqual(1, queriedMapElementList.Count, $@"Database query for inserted MapElement
returned list with number of entries different than one.
Expected: 1,
Actual: {queriedMapElementList.Count}.");
var queriedMapElement = queriedMapElementList.First() as MapPolygonItem;
Assert.IsNotNull(queriedMapElement, "Map element is null.");
Assert.AreEqual(insertedPolygon.Id, queriedMapElement.Id, $@"Method returned
MapElement with differrent Id.
Expected: {insertedPolygon.Id},
Actual: {queriedMapElement.Id}.");
Assert.AreEqual(insertedPolygon.Name, queriedMapElement.Name, $@"Method returned
MapElement with different Name.
Expected: {insertedPolygon.Name},
Actual: {queriedMapElement.Name}.");
Assert.AreEqual(insertedLayer.Id, queriedMapElement.ParentLayer.Id, $@"Method returned
MapElement with different parent layer.
Expected: {insertedLayer.Id},
Actual: {queriedMapElement.ParentLayer.Id}.");
Assert.AreEqual(insertedPolygon.FillColor, queriedMapElement.FillColor, $@"Method returned
MapElement with different fill color.
Expected: {insertedPolygon.FillColor},
Actual: {queriedMapElement.FillColor}.");
Assert.AreEqual(insertedPolygon.StrokeColor, queriedMapElement.StrokeColor, $@"Method returned
MapElement with different stroke color.
Expected: {insertedPolygon.StrokeColor},
Actual: {queriedMapElement.StrokeColor}.");
}
taskSource.SetResult(null);
}
catch (Exception e)
{
taskSource.SetException(e);
}
});
await taskSource.Task;
}
public async Task InsertMapPolylineItemAsync_InsertsMapElementCorrectly()
{
var taskSource = new TaskCompletionSource <object>();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
try
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
var path = new List <BasicGeoposition>()
{
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
new BasicGeoposition()
{
Latitude = 3, Longitude = 4
}
};
var insertedPolyline = MapElementItemFactoryService.GetMapPolylineItem(
"Test polyline", path, insertedLayer, Color.FromArgb(0, 0, 0, 0), 0.00001);
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
await DatabaseAccessService.InsertMapPolylineItemAsync(insertedPolyline);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedMapElementList = (cnn.Query <dynamic>($"SELECT * FROM MapElement WHERE Id={insertedPolyline.Id}")).ToList();
Assert.AreEqual(1, queriedMapElementList.Count, $@"Database query for inserted MapElement returned list with number of entries
different than one.
Expected: 1,
Actual: {queriedMapElementList.Count}.");
var queriedMapElement = queriedMapElementList.First();
Assert.IsNotNull(queriedMapElement, "Database query for inserted MapElement returned null.");
Assert.AreEqual(insertedPolyline.Id, queriedMapElement.Id, $@"Database query for inserted MapElement returned
MapElement with differrent Id.
Expected: {insertedPolyline.Id},
Actual: {queriedMapElement.Id}.");
Assert.AreEqual(insertedPolyline.Name, queriedMapElement.Name, $@"Database query for inserted MapElement returned
MapElement with different Name.
Expected: {insertedPolyline.Name},
Actual: {queriedMapElement.Name}.");
Assert.AreEqual(insertedLayer.Id, queriedMapElement.Layer_Id, $@"Database query for inserted MapElement returned
MapElement with different parent layer.
Expected: {insertedLayer.Id},
Actual: {queriedMapElement.Layer_id}.");
Assert.AreEqual(insertedPolyline.Width, queriedMapElement.Width, $@"Database query for inserted MapElement returned
MapElement with different width.
Expected: {insertedPolyline.Width},
Actual: {queriedMapElement.Width}.");
}
taskSource.SetResult(null);
}
catch (Exception e)
{
taskSource.SetException(e);
}
});
await taskSource.Task;
}
public async Task InsertMapIconItemAsync_InsertsElementCorrectly()
{
var taskSource = new TaskCompletionSource <object>();
// using dispatcher to run the test in ui thread.
// using UITestMethod attribute was umpossible because it
// doesn't support async
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
try
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
var insertedIcon = MapElementItemFactoryService.GetMapIconItem(
"Test Icon",
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
insertedLayer,
123);
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
await DatabaseAccessService.InsertMapIconItemAsync(insertedIcon);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedMapElementList = (cnn.Query <dynamic>($"SELECT * FROM MapElement WHERE Id={insertedIcon.Id}")).ToList();
Assert.AreEqual(1, queriedMapElementList.Count, $@"Database query for inserted MapElement returned list with number of entries
different than one.
Expected: 1,
Actual: {queriedMapElementList.Count}.");
var queriedMapElement = queriedMapElementList.First();
Assert.IsNotNull(queriedMapElement, "Database query for inserted MapElement returned null.");
Assert.AreEqual(insertedIcon.Id, queriedMapElement.Id, $@"Database query for inserted MapElement returned
MapElement with differrent Id.
Expected: {insertedIcon.Id},
Actual: {queriedMapElement.Id}.");
Assert.AreEqual(insertedIcon.Name, queriedMapElement.Name, $@"Database query for inserted MapElement returned
MapElement with different Name.
Expected: {insertedIcon.Name},
Actual: {queriedMapElement.Name}.");
Assert.AreEqual(insertedLayer.Id, queriedMapElement.Layer_Id, $@"Database query for inserted MapElement returned
MapElement with different parent layer.
Expected: {insertedLayer.Id},
Actual: {queriedMapElement.Layer_id}.");
}
taskSource.SetResult(null);
}
catch (Exception e)
{
taskSource.SetException(e);
}
});
await taskSource.Task;
}
private async Task CreateAndAddMapIconAsync(BasicGeoposition position, string title, MapLayerItem layer)
{
var pos = new BasicGeoposition()
{
Longitude = position.Longitude, Latitude = position.Latitude
};
var newItem = MapElementItemFactoryService.GetMapIconItem(title, pos, layer);
AddMapElementItem(newItem);
await DatabaseAccessService.InsertMapIconItemAsync(newItem);
}
void GenerateStoneWallAndEdge()
{
int index = currMapScene.layers.IndexOf(MapEditorSortLayer.Floor1);
MapLayerItem mapLayerItem = currMapScene.layerItems[index];
for (int i = 0; i < mapLayerItem.items.Count; i++)
{
if (mapLayerItem.items[i].itemType == MapEditorItemType.Wall)
{
int x = mapLayerItem.posList[i] / 10000;
int y = mapLayerItem.posList[i] % 10000;
if (y == 0)
{
continue;
}
index = mapLayerItem.posList.IndexOf(x * 10000 + y - 1);
if (index != -1 && (mapLayerItem.items[index].itemType != MapEditorItemType.Wall && mapLayerItem.items[index].itemType != MapEditorItemType.StoneWall))
{
mapLayerItem.items[i] = mapLayerItem.items[i].replaceItem;
}
}
}
for (int i = 0; i < mapLayerItem.items.Count; i++)
{
if (mapLayerItem.items[i].itemType != MapEditorItemType.Wall && mapLayerItem.items[i].itemType != MapEditorItemType.StoneWall)
{
int x = mapLayerItem.posList[i] / 10000;
int y = mapLayerItem.posList[i] % 10000;
int index1 = mapLayerItem.posList.IndexOf(x * 10000 + y + 1);
int index2 = mapLayerItem.posList.IndexOf((x - 1) * 10000 + y);
int index3 = mapLayerItem.posList.IndexOf((x + 1) * 10000 + y);
bool wall1 = index1 != -1 && (mapLayerItem.items[index1].itemType == MapEditorItemType.Wall || mapLayerItem.items[index1].itemType == MapEditorItemType.StoneWall);
bool wall2 = index2 != -1 && (mapLayerItem.items[index2].itemType == MapEditorItemType.Wall || mapLayerItem.items[index2].itemType == MapEditorItemType.StoneWall);
bool wall3 = index3 != -1 && (mapLayerItem.items[index3].itemType == MapEditorItemType.Wall || mapLayerItem.items[index3].itemType == MapEditorItemType.StoneWall);
MapResourceItem edge = null;
if (wall1 && wall2 && wall3)
{
edge = mapLayerItem.items[index1].replaceEdgeSingleUp;
}
else if (wall1 && wall2 && !wall3)
{
edge = mapLayerItem.items[index1].replaceEdgeLeftUp;
}
else if (wall1 && !wall2 && wall3)
{
edge = mapLayerItem.items[index1].replaceEdgeRightUp;
}
else if (wall1 && !wall2 && !wall3)
{
edge = mapLayerItem.items[index1].replaceEdgeUp;
}
else if (!wall1 && wall2 && wall3)
{
edge = mapLayerItem.items[index2].replaceEdgeVer;
}
else if (!wall1 && wall2 && !wall3)
{
edge = mapLayerItem.items[index2].replaceEdgeLeft;
}
else if (!wall1 && !wall2 && wall3)
{
edge = mapLayerItem.items[index3].replaceEdgeRight;
}
else
{
edge = null;
}
if (edge != null)
{
index = currMapScene.layers.IndexOf(MapEditorSortLayer.Floor2);
MapLayerItem mapLayerEdgeItem = null;
if (index == -1)
{
currMapScene.layers.Add(MapEditorSortLayer.Floor2);
mapLayerEdgeItem = new MapLayerItem();
currMapScene.layerItems.Add(mapLayerEdgeItem);
}
else
{
mapLayerEdgeItem = currMapScene.layerItems[index];
}
index = mapLayerEdgeItem.posList.IndexOf(x * 10000 + y);
if (index == -1)
{
mapLayerEdgeItem.posList.Add(x * 10000 + y);
mapLayerEdgeItem.items.Add(edge);
}
else
{
mapLayerEdgeItem.items[index] = edge;
}
}
}
}
}
private async Task CreateAndAddMapPolygonAsync(IReadOnlyList <BasicGeoposition> path, Color fillColor, Color strokeColor, string name, MapLayerItem layer)
{
var newItem = MapElementItemFactoryService.GetMapPolygonItem(name, path, layer, strokeColor, fillColor);
AddMapElementItem(newItem);
await DatabaseAccessService.InsertMapPolygonItemAsync(newItem);
}
