public void CanAdaptTheSameNonTerrainMeshOnlyOnce(string name)
{
name += ":42";
var vertices = new double[] { .0, 0, 0 };
GCHandle verticesPinned = GCHandle.Alloc(vertices, GCHandleType.Pinned);
var triangles = new int[] { 0, 0, 0 };
GCHandle trianglesPinned = GCHandle.Alloc(triangles, GCHandleType.Pinned);
var colors = new int[] { 0, 0, 0 };
GCHandle colorsPinned = GCHandle.Alloc(colors, GCHandleType.Pinned);
var uvs = new double[] { .0, 0, 0, .0, 0, 0 };
GCHandle uvsPinned = GCHandle.Alloc(uvs, GCHandleType.Pinned);
var uvMap = new int[0] {
};
GCHandle uvMapPinned = GCHandle.Alloc(uvMap, GCHandleType.Pinned);
for (int i = 0; i < 2; ++i)
{
MapDataAdapter.AdaptMesh(_tile.GetHashCode(),
name,
verticesPinned.AddrOfPinnedObject(), vertices.Length,
trianglesPinned.AddrOfPinnedObject(), triangles.Length,
colorsPinned.AddrOfPinnedObject(), colors.Length,
uvsPinned.AddrOfPinnedObject(), uvs.Length,
uvMapPinned.AddrOfPinnedObject(), uvMap.Length);
}
_observer.Verify(o => o.OnNext(It.IsAny <MapData>()), Times.Once);
}
/// <summary>
/// Load data from file
/// </summary>
private void LoadData()
{
var adapter = new MapDataAdapter(DATAFILE);
MapData data;
try
{
data = adapter.Load();
}
catch (Exception ex)
{
MessageBox.Show(Properties.Resources.ErrorOnLoad + " " + ex);
return;
}
foreach (var d in data.Items)
{
var mapItem = new MapDataItemVM(d);
mapItem.Selected += new EventHandler <EventArgs>(OnSelectCurrentItem);
MapItems.Add(mapItem);
}
// from now on, track changes
MapItems.CollectionChanged +=
new System.Collections.Specialized.NotifyCollectionChangedEventHandler((o, e) => { _itemCollectionChanged = true; });
}
public Outcome Execute()
{
MapWebAPIComm network = new MapWebAPIComm();
var requestDTO = new NetworkLocationDTO()
{
Location = RequestedLocation
};
// Waits for the request to finish
// TODO: I need to fix this Task.Run issue
var test = Task.Run(async() => { return(await network.Request(requestDTO)); }).Result;
// Converts the data from the web api
MapDataAdapter dataMapper = new MapDataAdapter();
var mappedData = dataMapper.Convert(test.Response);
ValidatedLocation = mappedData;
// Validating County based on the scope
if (ValidatedLocation.County != null && (ValidatedLocation.County.Equals("Los Angeles County") || ValidatedLocation.County.Equals("Orange County")))
{
ValidatedLocation.IsValid = true;
}
else
{
ValidatedLocation.IsValid = false;
}
return(new Outcome()
{
Result = ValidatedLocation
});
}
public void Setup()
{
_tile = new Tile(new QuadKey(), new Mock <Stylesheet>("").Object, new Mock <IProjection>().Object, ElevationDataType.Flat);
_observer = new Mock <IObserver <MapData> >();
MapDataAdapter.Add(_tile);
MapDataAdapter.Add(_observer.Object);
}
public void LoadData()
{
using (new JoobContext())
{
if (MapDataAdapter.GetAllLayers().First().GeometryCount == 0)
{
////////// Load the STATES. ///////////////////////////////////
Console.WriteLine("Loading States:");
var stateImporter = new StateDataImporter(@".\..\JoobSpatialDemo\Data\US_States.txt");
stateImporter.ImportCompleted += ImporterCompleted;
stateImporter.ProgressChanged += ImporterProgressChanged;
stateImporter.ImportAsync();
while (ImportDone < 1)
{
Thread.Sleep(1);
}
Console.WriteLine("\rStates loaded. ");
////////////////////////////////////////////////////////////////////
////////// Load the COUNTIES. //////////////////////////////////
Console.WriteLine("Loading Counties:");
var countyImporter = new CountyDataImporter(@".\..\JoobSpatialDemo\Data\US_Counties.txt");
countyImporter.ImportCompleted += ImporterCompleted;
countyImporter.ProgressChanged += ImporterProgressChanged;
countyImporter.ImportAsync();
while (ImportDone < 2)
{
Thread.Sleep(1);
}
Console.WriteLine("\rCounties loaded. ");
////////////////////////////////////////////////////////////////////
////////// Load the CITIES. ////////////////////////////////////
Console.WriteLine("Loading Cities:");
var cityImporter = new CityDataImporter(@".\..\JoobSpatialDemo\Data\US_Cities.txt");
cityImporter.ImportCompleted += ImporterCompleted;
cityImporter.ProgressChanged += ImporterProgressChanged;
cityImporter.ImportAsync();
while (ImportDone < 3)
{
Thread.Sleep(1);
}
Console.WriteLine("\rCities loaded. ");
////////////////////////////////////////////////////////////////////
}
}
}
private static void OnElementLoadedHandler(int tag, long id, IntPtr tagPtr, int tagCount,
IntPtr vertexPtr, int vertexCount, IntPtr stylePtr, int styleCount)
{
Tile tile;
if (!Tiles.TryGetValue(tag, out tile) || tile.IsDisposed)
{
return;
}
// NOTE see note above
var vertices = MarshalUtils.ReadDoubles(vertexPtr, vertexCount);
var tags = MarshalUtils.ReadStrings(tagPtr, tagCount);
var styles = MarshalUtils.ReadStrings(stylePtr, styleCount);
MapDataAdapter.AdaptElement(tile, _observers, _trace, id, vertices, tags, styles);
}
private static void OnMeshBuiltHandler(int tag, string name, IntPtr vertexPtr, int vertexCount,
IntPtr trianglePtr, int triangleCount, IntPtr colorPtr, int colorCount,
IntPtr uvPtr, int uvCount, IntPtr uvMapPtr, int uvMapCount)
{
Tile tile;
if (!Tiles.TryGetValue(tag, out tile) || tile.IsDisposed)
{
return;
}
// NOTE ideally, arrays should be marshalled automatically which could enable some optimizations,
// especially, for il2cpp. However, I was not able to make it work using il2cpp setting: all arrays
// were passed to this method with just one element. I gave up and decided to use manual marshalling
// here and in AdaptElement method below.
var vertices = MarshalUtils.ReadDoubles(vertexPtr, vertexCount);
var triangles = MarshalUtils.ReadInts(trianglePtr, triangleCount);
var colors = MarshalUtils.ReadInts(colorPtr, colorCount);
var uvs = MarshalUtils.ReadDoubles(uvPtr, uvCount);
var uvMap = MarshalUtils.ReadInts(uvMapPtr, uvMapCount);
MapDataAdapter.AdaptMesh(tile, _observers, _trace, name, vertices, triangles, colors, uvs, uvMap);
}
/// <summary>
/// Checks if the address is in the scope of Whatfits by sending a request to Google Maps Web API
/// </summary>
/// <param name="address"> location based on users input </param>
/// <returns> status of the validation of the location </returns>
public bool CheckAddress(string address)
{
var location = address.Replace(' ', '+');
MapWebAPIComm network = new MapWebAPIComm();
var requestDTO = new NetworkLocationDTO()
{
Location = location
};
// Waits for the request to finish
var test = Task.Run(async() => { return(await network.Request(requestDTO)); }).Result;
// Converts the data from the web api
MapDataAdapter dataMapper = new MapDataAdapter();
var mappedData = dataMapper.Convert(test.Response);
// Validating County based on the scope
if (mappedData.County != null && (mappedData.County.Equals("Los Angeles County") || mappedData.County.Equals("Orange County")))
{
ValidatedLocation = mappedData;
return(true);
}
return(false);
}
/// <summary>
/// Save data to file
/// </summary>
/// <param name="param"></param>
private void SaveData(object param)
{
var data = new MapData();
data.Items.AddRange(
MapItems.Select(i =>
new MapDataItem {
X = i.RealCoords.X,
Y = i.RealCoords.Y,
Name = i.Title,
Description = i.Description,
PresentationFileName = i.PresentationFile
}));
var adapter = new MapDataAdapter(DATAFILE);
adapter.Save(data);
foreach (var item in MapItems)
{
item.ResetChanged();
}
_itemCollectionChanged = false;
}
public void TearDown()
{
MapDataAdapter.Clear();
}
private void HandleMapComplementaryInformationsDataMessage(MapComplementaryInformationsDataMessage message, ConnectedHost source)
{
Data = MapDataAdapter.GetMap(message.mapId);
Actors = new Dictionary <int, ActorModel>();
Monsters = new Dictionary <int, GroupOfMonstersModel>();
Characters = new Dictionary <int, CharacterModel>();
Npcs = new Dictionary <int, NpcModel>();
Interactives = new Dictionary <int, ElementModel>();
Doors = new Dictionary <int, ElementModel>();
X = GameDataAdapter.GetClass <MapPosition>((int)Data.Id).PosX;
Y = GameDataAdapter.GetClass <MapPosition>((int)Data.Id).PosY;
WorldId = GameDataAdapter.GetClass <MapPosition>((int)Data.Id).WorldMap;
foreach (var mess in message.actors)
{
switch (mess.TypeId)
{
case GameRolePlayNpcInformations.Id:
Npcs.Add(mess.contextualId, new NpcModel((GameRolePlayNpcInformations)mess));
break;
case GameRolePlayNpcWithQuestInformations.Id:
Npcs.Add(mess.contextualId, new NpcModel((GameRolePlayNpcInformations)mess));
break;
case GameRolePlayCharacterInformations.Id:
Characters.Add(mess.contextualId, new CharacterModel((GameRolePlayCharacterInformations)mess));
break;
case GameRolePlayGroupMonsterInformations.Id:
Monsters.Add(mess.contextualId, new GroupOfMonstersModel((GameRolePlayGroupMonsterInformations)mess));
break;
}
Actors.Add(mess.contextualId, new ActorModel((GameRolePlayActorInformations)mess));
}
foreach (var element in message.interactiveElements)
{
Interactives.Add(element.elementId, new ElementModel(element));
InteractiveElement interactiveElement = element;
List <int> listDoorSkillId = new List <int>(new[] { 184, 183, 187, 198, 114 });
List <int> listDoorTypeId = new List <int>(new[] { -1, 128, 168, 16 });
if (listDoorTypeId.Contains(interactiveElement.elementTypeId) && (interactiveElement.enabledSkills.Length > 0) && (listDoorSkillId.Contains((int)interactiveElement.enabledSkills[0].skillId)))
{
foreach (var layer in Data.Layers)
{
foreach (var cell in layer.cells)
{
foreach (var layerElement in cell.elements)
{
if (layerElement is GraphicalElement)
{
GraphicalElement graphicalElement = (GraphicalElement)layerElement;
if ((graphicalElement.identifier == interactiveElement.elementId) && !Doors.ContainsKey(cell.cellId))
{
Doors.Add(element.elementId, new ElementModel(element));
}
}
}
}
}
}
}
foreach (StatedElement element in message.statedElements)
{
ElementModel value;
if (Interactives.TryGetValue(element.elementId, out value))
{
value.Update(element);
}
}
source.Bot.Game.Player.mPathFinder.SetMap(this, false);
OnUpdated();
}
