public void Along()
{
var line = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("fixtures_dc-line.geojson"));
var pt1 = Turf.Along(line, 1, "miles");
var pt2 = Turf.Along((LineString)line.Geometry, 1.2, "miles");
var pt3 = Turf.Along(line, 1.4, "miles");
var pt4 = Turf.Along((LineString)line.Geometry, 1.6, "miles");
var pt5 = Turf.Along(line, 1.8, "miles");
var pt6 = Turf.Along((LineString)line.Geometry, 2, "miles");
var pt7 = Turf.Along(line, 100, "miles");
var pt8 = Turf.Along((LineString)line.Geometry, 0, "miles");
var fc = new FeatureCollection(new List <Feature>()
{
pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8
});
foreach (var f in fc.Features)
{
Assert.AreEqual(f.Type, GeoJSONObjectType.Feature);
Assert.AreEqual(f.Geometry.Type, GeoJSONObjectType.Point);
}
Assert.AreEqual(fc.Features.Count, 8);
var exp = (GeographicPosition)((Point)fc.Features[7].Geometry).Coordinates;
var act = (GeographicPosition)((Point)pt8.Geometry).Coordinates;
Assert.AreEqual(exp.Longitude, act.Longitude);
Assert.AreEqual(exp.Latitude, act.Latitude);
}
//Initialize the tile, add the turf component and tell the turf the tiletype
public void initTile()
{
if (turf == null)
{
turf = (Turf)gameObject.AddComponent(typeof(Turf));
//Debug.Log("Adding Component: turf");
}
gameObject.GetComponent <Turf>().turfDescriptor = TileDescriptor;
gameObject.GetComponent <Turf>().InitTurf();
if (contentManager == null)
{
contentManager = (TileContentManager)gameObject.AddComponent(typeof(TileContentManager));
//Debug.Log("Adding Component: turf");
}
gameObject.GetComponent <TileContentManager>().InitTileContentManager();
if (pipeManager == null)
{
pipeManager = (TilePipeManager)gameObject.AddComponent(typeof(TilePipeManager));
//Debug.Log("Adding Component: turf");
}
gameObject.GetComponent <TilePipeManager>().InitTilePipeManager();
if (tileNetworkManager == null)
{
tileNetworkManager = (Mirror.TileNetworkManager)gameObject.AddComponent(typeof(Mirror.TileNetworkManager));
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
Turf targetScript = (Turf)target;
if (GUILayout.Button("build_upper_turf"))
{
targetScript.BuildUpper();
}
if (GUILayout.Button("build_lower_turf"))
{
targetScript.BuildLower();
}
if (GUILayout.Button("build_turf"))
{
targetScript.BuildTurf();
}
if (GUILayout.Button("update_turf"))
{
targetScript.UpdateTurf();
}
if (GUILayout.Button("update_neighbour_turf"))
{
targetScript.UpdateNeighbourTurf();
}
}
public void Center()
{
var boxFC = JsonConvert.DeserializeObject <FeatureCollection>(Tools.GetResource("center.box.geojson"));
var blockFC = JsonConvert.DeserializeObject <FeatureCollection>(Tools.GetResource("center.block.geojson"));
var boxFcCenter = Turf.Center(boxFC);
boxFcCenter.Properties["marker-color"] = "#f0f";
var boxFcCenterArray = Turf.GetCoord(boxFcCenter);
Assert.AreEqual(boxFcCenterArray[0], 65.56640625, 0.00001);
Assert.AreEqual(boxFcCenterArray[1], 43.59448261855401, 0.00001);
var blockFcCenter = Turf.Center(blockFC.Features[0]);
blockFcCenter.Properties["marker-color"] = "#f0f";
var blockFcCenterArray = Turf.GetCoord(blockFcCenter);
Assert.AreEqual(blockFcCenterArray[0], -114.02911397119072, 0.00001);
Assert.AreEqual(blockFcCenterArray[1], 51.050271120392566, 0.00001);
boxFC.Features.Add(boxFcCenter);
blockFC.Features.Add(blockFcCenter);
Console.WriteLine(JsonConvert.SerializeObject(boxFC));
Console.WriteLine(JsonConvert.SerializeObject(blockFC));
}
public override void ReadFromBuffer(NetIncomingMessage buffer)
{
MessageType = (MapMessage)buffer.ReadByte();
switch (MessageType)
{
case MapMessage.TurfUpdate:
SingleTurf = new Turf()
{
X = buffer.ReadInt32(),
Y = buffer.ReadInt32(),
Tile = buffer.ReadUInt32()
};
break;
case MapMessage.SendTileMap:
GridIndex = buffer.ReadInt32();
MapIndex = buffer.ReadInt32();
//tile defs
var numTileDefs = buffer.ReadInt32();
var tileDefs = new TileDef[numTileDefs];
for (var i = 0; i < numTileDefs; i++)
{
tileDefs[i] = new TileDef()
{
Name = buffer.ReadString()
};
}
TileDefs = tileDefs;
// map chunks
ChunkSize = buffer.ReadUInt16();
var numChunks = buffer.ReadInt32();
ChunkDefs = new ChunkDef[numChunks];
for (var i = 0; i < numChunks; i++)
{
var newChunk = new ChunkDef()
{
X = buffer.ReadInt32(),
Y = buffer.ReadInt32()
};
var chunkCount = ChunkSize * ChunkSize;
var tiles = new uint[chunkCount];
for (var j = 0; j < chunkCount; j++)
{
tiles[j] = buffer.ReadUInt32();
}
newChunk.Tiles = tiles;
ChunkDefs[i] = newChunk;
}
break;
case MapMessage.SendMapInfo:
MapGridsToSend = buffer.ReadInt32();
break;
}
}
public void TestDistance()
{
var from = new Coordinate(-75.343, 39.984);
var to = new Coordinate(-75.534, 39.123);
var d = Turf.Distance(from, to);
Assert.AreEqual(d, 97.12922118967835);
}
public void TestAlong()
{
var line = new LineString(new Coordinate[] { new Coordinate(-83, 30), new Coordinate(-84, 36), new Coordinate(-78, 41) });
var along = Turf.Along(line, 200);
Assert.AreEqual(along.ToText(), "POINT (-84 36)");
}
public void Bearing()
{
var pt1 = Turf.Point(new double[] { -75.4, 39.4 });
var pt2 = Turf.Point(new double[] { -75.534, 39.123 });
var bear = Turf.Bearing(pt1, pt2);
Assert.AreEqual(bear, -159.42, 0.01, "should return the correct bearing");
}
public void Tin()
{
var points = JsonConvert.DeserializeObject <FeatureCollection>(Tools.GetResource("Points.geojson"));
var tinned = Turf.Tin(points, "elevation");
Assert.AreEqual(tinned.Features[0].Geometry.Type, GeoJSONObjectType.Polygon);
Assert.AreEqual(tinned.Features.Count, 24);
Console.WriteLine(JsonConvert.SerializeObject(tinned));
}
public void Bbox()
{
var fc = JsonConvert.DeserializeObject <FeatureCollection>(Tools.GetResource("bbox.FeatureCollection.geojson"));
var pt = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("bbox.Point.geojson"));
var line = JsonConvert.DeserializeObject <LineString>(Tools.GetResource("bbox.LineString.geojson"));
var poly = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("bbox.Polygon.geojson"));
var multiLine = JsonConvert.DeserializeObject <MultiLineString>(Tools.GetResource("bbox.MultiLineString.geojson"));
var multiPoly = JsonConvert.DeserializeObject <MultiPolygon>(Tools.GetResource("bbox.MultiPolygon.geojson"));
// FeatureCollection
var fcExtent = Turf.Bbox(fc);
Assert.AreEqual(fcExtent[0], 20);
Assert.AreEqual(fcExtent[1], -10);
Assert.AreEqual(fcExtent[2], 130);
Assert.AreEqual(fcExtent[3], 4);
// Point
var ptExtent = Turf.Bbox(pt);
Assert.AreEqual(ptExtent[0], 102);
Assert.AreEqual(ptExtent[1], 0.5);
Assert.AreEqual(ptExtent[2], 102);
Assert.AreEqual(ptExtent[3], 0.5);
// Line
var lineExtent = Turf.Bbox(line);
Assert.AreEqual(lineExtent[0], 102);
Assert.AreEqual(lineExtent[1], -10);
Assert.AreEqual(lineExtent[2], 130);
Assert.AreEqual(lineExtent[3], 4);
// Polygon
var polyExtent = Turf.Bbox(poly);
Assert.AreEqual(polyExtent[0], 100);
Assert.AreEqual(polyExtent[1], 0);
Assert.AreEqual(polyExtent[2], 101);
Assert.AreEqual(polyExtent[3], 1);
// MultiLineString
var multiLineExtent = Turf.Bbox(multiLine);
Assert.AreEqual(multiLineExtent[0], 100);
Assert.AreEqual(multiLineExtent[1], 0);
Assert.AreEqual(multiLineExtent[2], 103);
Assert.AreEqual(multiLineExtent[3], 3);
// MultiPolygon
var multiPolyExtent = Turf.Bbox(multiPoly);
Assert.AreEqual(multiPolyExtent[0], 100);
Assert.AreEqual(multiPolyExtent[1], 0);
Assert.AreEqual(multiPolyExtent[2], 103);
Assert.AreEqual(multiPolyExtent[3], 3);
}
public void Nearest()
{
var pt = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("nearest.pt.geojson"));
var pts = JsonConvert.DeserializeObject <FeatureCollection>(Tools.GetResource("nearest.pts.geojson"));
var closestPt = Turf.Nearest(pt, pts);
Assert.AreEqual(closestPt.Geometry.Type, GeoJSONObjectType.Point, "should be a point");
Assert.AreEqual(((GeographicPosition)((Point)closestPt.Geometry).Coordinates).Longitude, -75.33, "lon -75.33");
Assert.AreEqual(((GeographicPosition)((Point)closestPt.Geometry).Coordinates).Latitude, 39.44, "lat 39.44");
}
public void updateTurfs()
{
foreach (GameObject tileobj in tile_list)
{
Turf tile_turf = tileobj.GetComponent <Turf>();
if (tile_turf != null)
{
tile_turf.UpdateTurf();
}
}
}
public void Inside_PolyWithHole()
{
var ptInHole = Turf.Point(new double[] { -86.69208526611328, 36.20373274711739 });
var ptInPoly = Turf.Point(new double[] { -86.72229766845702, 36.20258997094334 });
var ptOutsidePoly = Turf.Point(new double[] { -86.75079345703125, 36.18527313913089 });
var polyHole = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("poly-with-hole.geojson"));
Assert.False(Turf.Inside(ptInHole, polyHole));
Assert.True(Turf.Inside(ptInPoly, polyHole));
Assert.False(Turf.Inside(ptOutsidePoly, polyHole));
}
public void LineDistance()
{
var route1 = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("linedistance.route1.geojson"));
var route2 = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("linedistance.route2.geojson"));
Assert.AreEqual(Math.Round(Turf.LineDistance((IGeoJSONObject)route1.Geometry, "miles")), 202);
var point1 = Turf.Point(new double[] { -75.343, 39.984 });
try
{
Turf.LineDistance(point1, "miles");
Assert.Fail();
}
catch
{
Assert.Pass();
}
var multiPoint1 = new MultiPoint(new List <Point>()
{
new Point(new GeographicPosition(39.984, -75.343)),
new Point(new GeographicPosition(39.123, -75.534))
});
try
{
Turf.LineDistance(multiPoint1, "miles");
Assert.Fail();
}
catch
{
Assert.Pass();
}
Assert.AreEqual(Math.Round(Turf.LineDistance(route1, "miles")), 202);
Assert.True((Turf.LineDistance(route2, "kilometers") - 742) < 1 && (Turf.LineDistance(route2, "kilometers") - 742) > (-1));
var feat = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("linedistance.polygon.geojson"));
Assert.AreEqual(Math.Round(1000 * Turf.LineDistance(feat, "kilometers")), 5599);
feat = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("linedistance.multilinestring.geojson"));
Assert.AreEqual(Math.Round(1000 * Turf.LineDistance(feat, "kilometers")), 4705);
feat = JsonConvert.DeserializeObject <Feature>(Tools.GetResource("linedistance.multipolygon.geojson"));
Assert.AreEqual(Math.Round(1000 * Turf.LineDistance(feat, "kilometers")), 8334);
var fc = JsonConvert.DeserializeObject <FeatureCollection>(Tools.GetResource("linedistance.featurecollection.geojson"));
Assert.AreEqual(Math.Round(1000 * Turf.LineDistance(fc, "kilometers")), 10304);
}
public override bool CanInteract(InteractionEvent interactionEvent)
{
var tileObject = interactionEvent.Target.GetComponent <TileObject>();
TileDefinition tile = tileObject.Tile;
Turf existingTurf = tile.turf;
if (existingTurf && (!ConstructIfTurf || existingTurf.isWall && !ConstructIfWall))
{
return(false);
}
return(base.CanInteract(interactionEvent));
}
public void TestArea()
{
var polygon = new Polygon(new LinearRing(new Coordinate[] {
new Coordinate(125, -15),
new Coordinate(113, -22),
new Coordinate(154, -27),
new Coordinate(144, -15),
new Coordinate(125, -15),
}));
var a = Turf.Area(polygon);
Assert.AreEqual(a, 3339946239196.927);
}
public void Circle()
{
var center = Turf.Point(new double[] { -75.343, 39.984 });
double radius = 5;
int steps = 10;
var polygon = Turf.Circle(center, radius, steps, "kilometers");
var point1 = Turf.Destination(center, radius - 1, 45, "kilometers");
var point2 = Turf.Destination(center, radius + 1, 135, "kilometers");
Assert.AreEqual(Turf.Inside(point1, polygon), true, "point is inside the polygon");
Assert.AreEqual(Turf.Inside(point2, polygon), false, "point is outside the polygon");
}
public void Distance()
{
var pt1 = Turf.Point(new double[] { -75.343, 39.984 });
var pt2 = Turf.Point(new double[] { -75.534, 39.123 });
Assert.AreEqual(Turf.Distance(pt1, pt2, "miles"), 60.37218405837491, 0.00001, "miles");
Assert.AreEqual(Turf.Distance(pt1, pt2, "nauticalmiles"), 52.461979624130436, 0.00001, "miles");
Assert.AreEqual(Turf.Distance(pt1, pt2, "kilometers"), 97.15957803131901, 0.00001, "kilometers");
Assert.AreEqual(Turf.Distance(pt1, pt2, "kilometres"), 97.15957803131901, 0.00001, "kilometres");
Assert.AreEqual(Turf.Distance(pt1, pt2, "radians"), 0.015245501024842149, 0.00001, "radians");
Assert.AreEqual(Turf.Distance(pt1, pt2, "degrees"), 0.8735028650863799, 0.00001, "degrees");
Assert.AreEqual(Turf.Distance(pt1, pt2), 97.15957803131901, 0.00001, "default=kilometers");
}
public void Destination()
{
var pt1 = Turf.Point(new double[] { -75.0, 39.0 });
double dist = 100;
double bear = 180;
var pt2 = Turf.Destination(pt1, dist, bear, "kilometers");
var ptgeom = (Point)pt2.Geometry;
var prcoord = (GeographicPosition)ptgeom.Coordinates;
Assert.AreEqual(prcoord.Longitude, -75, 0.001, "returns the correct point");
Assert.AreEqual(prcoord.Latitude, 38.10096062273525, 0.001, "returns the correct point");
Assert.AreEqual(ptgeom.Type, GeoJSONObjectType.Point, "returns the correct point");
}
public void BboxPolygon()
{
var poly = Turf.BboxPolygon(new List <double>()
{
0, 0, 10, 10
});
Assert.AreEqual(poly.Geometry.Type, GeoJSONObjectType.Polygon, "should be a Polygon geometry type");
var coords = ((Polygon)poly.Geometry).Coordinates[0].Coordinates;
Assert.AreEqual(coords.Count, 5);
Assert.AreEqual(((GeographicPosition)coords[0]).Latitude, ((GeographicPosition)coords[coords.Count - 1]).Latitude);
Assert.AreEqual(((GeographicPosition)coords[0]).Longitude, ((GeographicPosition)coords[coords.Count - 1]).Longitude);
}
public void PropEach()
{
Action <Dictionary <string, object>, int> callback = (Dictionary <string, object> obj, int i) =>
{
Assert.AreEqual(obj, new Dictionary <string, object>()
{
{ "a", 1 }
});
Assert.AreEqual(i, 0);
};
Turf.PropEach(pointFeature, callback);
var pointCollect = Collection(pointFeature);
Turf.PropEach(pointCollect, callback);
}
public void Tag()
{
var points = JsonConvert.DeserializeObject <FeatureCollection>(Tools.GetResource("tagPoints.geojson"));
var polygons = JsonConvert.DeserializeObject <FeatureCollection>(Tools.GetResource("tagPolygons.geojson"));
var taggedPoints = Turf.Tag(points, polygons, "polyID", "containingPolyID");
Assert.AreEqual(taggedPoints.Features.Count, points.Features.Count,
"tagged points should have the same length as the input points");
var count = taggedPoints.Features.Where(x =>
{
object val;
x.Properties.TryGetValue("containingPolyID", out val);
return(val != null && int.Parse(val.ToString()) == 4);
}).Count();
Assert.AreEqual(count, 6, "polygon 4 should have tagged 6 points");
}
public override void ReadFromBuffer(NetIncomingMessage buffer)
{
MessageType = (MapMessage)buffer.ReadByte();
switch (MessageType)
{
case MapMessage.TurfUpdate:
SingleTurf = new Turf()
{
X = buffer.ReadInt32(),
Y = buffer.ReadInt32(),
Tile = buffer.ReadUInt32()
};
break;
case MapMessage.SendTileMap:
//not dealing with this right now...
throw new NotImplementedException();
break;
}
}
public void Inside_FeatureCollection()
{
// test for a simple polygon
var poly = new Feature(new Polygon(new List <LineString>()
{
new LineString(new List <Position>()
{
new GeographicPosition(0, 0),
new GeographicPosition(100, 0),
new GeographicPosition(100, 100),
new GeographicPosition(0, 100),
new GeographicPosition(0, 0)
})
}));
var ptIn = Turf.Point(new double[] { 50, 50 });
var ptOut = Turf.Point(new double[] { 140, 150 });
Assert.True(Turf.Inside(ptIn, poly), "point inside simple polygon");
Assert.False(Turf.Inside(ptOut, poly), "point outside simple polygon");
// test for a concave polygon
var concavePoly = new Feature(new Polygon(new List <LineString>()
{
new LineString(new List <Position>()
{
new GeographicPosition(0, 0),
new GeographicPosition(50, 50),
new GeographicPosition(100, 50),
new GeographicPosition(100, 100),
new GeographicPosition(0, 100),
new GeographicPosition(0, 0)
})
}));
var ptConcaveIn = Turf.Point(new double[] { 75, 75 });
var ptConcaveOut = Turf.Point(new double[] { 25, 50 });
Assert.True(Turf.Inside(ptConcaveIn, concavePoly), "point inside concave polygon");
Assert.False(Turf.Inside(ptConcaveOut, concavePoly), "point outside concave polygon");
}
public override bool CanInteract(InteractionEvent interactionEvent)
{
GameObject target = (interactionEvent.Target as IGameObjectProvider)?.GameObject;
if (target == null)
{
return(false);
}
if (!InteractionHelpers.RangeCheck(interactionEvent))
{
return(false);
}
// Needs to be used on tile
TileObject tileObject = target.GetComponentInParent <TileObject>();
if (tileObject == null || tileObject.Tile.turf == null)
{
return(false);
}
Turf turf = tileObject.Tile.turf;
// Check if welder is on
if ((interactionEvent.Source as IToggleable)?.GetState() == false)
{
return(false);
}
// Check if turf is in dict
if (!TurfReinforceList.ContainsKey(turf) && !TurfReinforceList.ContainsValue(turf))
{
return(false);
}
return(true);
}
public void MidPoint()
{
var units = "miles";
var pt1 = Turf.Point(new double[] { 0, 0 });
var pt2 = Turf.Point(new double[] { 10, 0 });
var mid = Turf.MidPoint(pt1, pt2);
Assert.AreEqual(Turf.Distance(pt1, mid, units), Turf.Distance(mid, pt2, units), 0.000001,
"midpoint -- horizonatal equator");
pt2 = Turf.Point(new double[] { 0, 10 });
mid = Turf.MidPoint(pt1, pt2);
Assert.AreEqual(Turf.Distance(pt1, mid, units), Turf.Distance(mid, pt2, units), 0.000001,
"midpoint -- vertical from equator");
mid = Turf.MidPoint(pt2, pt1);
Assert.AreEqual(Turf.Distance(pt1, mid, units), Turf.Distance(mid, pt2, units), 0.000001,
"midpoint -- vertical to equator");
pt1 = Turf.Point(new double[] { -1, 10 });
pt2 = Turf.Point(new double[] { 1, -1 });
mid = Turf.MidPoint(pt1, pt2);
Assert.AreEqual(Turf.Distance(pt1, mid, units), Turf.Distance(mid, pt2, units), 0.000001,
"midpoint -- diagonal back over equator");
pt1 = Turf.Point(new double[] { -5, -1 });
pt2 = Turf.Point(new double[] { 5, 10 });
mid = Turf.MidPoint(pt1, pt2);
Assert.AreEqual(Turf.Distance(pt1, mid, units), Turf.Distance(mid, pt2, units), 0.000001,
"midpoint -- diagonal forward over equator");
pt1 = Turf.Point(new double[] { 22.5, 21.94304553343818 });
pt2 = Turf.Point(new double[] { 92.10937499999999, 46.800059446787316 });
mid = Turf.MidPoint(pt1, pt2);
Assert.AreEqual(Turf.Distance(pt1, mid, units), Turf.Distance(mid, pt2, units), 0.000001,
"midpoint -- long distance");
}
public void Envelope()
{
var fc = JsonConvert.DeserializeObject <FeatureCollection>(Tools.GetResource("envelope.fc.geojson"));
var enveloped = Turf.Envelope(fc);
Assert.AreEqual(enveloped.Geometry.Type, GeoJSONObjectType.Polygon);
var exp = new List <List <double> >()
{
new List <double> ()
{
20, -10
},
new List <double> ()
{
130, -10
},
new List <double> ()
{
130, 4
},
new List <double> ()
{
20, 4
},
new List <double> ()
{
20, -10
}
};
var i = 0;
Turf.CoordEach(enveloped, (List <double> act) => {
Assert.AreEqual(act, exp[i], "positions are correct");
i++;
});
}
public Turf[,] GenerateActiveLayer(int size = 255)
{
MeshFilter objectMesh = ((GameObject)levelResources.loadedResources["turf"]).GetComponentInChildren <MeshFilter>();
List <GenerationAreaSettings> areaData = ReadGenerationSettings();
Turf[,] turfs = new Turf[size, size];
//Count how many rooms were made
int roomCount = 0;
int successfulCount = 0;
//Populate array with default values
for (int x = 0; x < size; x++)
{
for (int y = 0; y < size; y++)
{
turfs[x, y] = new Turf(x, y);
}
}
List <TileData> tilesToProcess = new List <TileData>();
TileData initialRoom = new TileData();
initialRoom.connection_x = 1;
initialRoom.connection_y = 0;
initialRoom.x = size / 2;
initialRoom.y = size / 2;
tilesToProcess.Add(initialRoom);
//Generate the rooms
while (tilesToProcess.Count > 0)
{
//Log the amount of rooms
roomCount++;
//Log.Print("Processing tile at " + tilesToProcess[0].x + "," + tilesToProcess[0].y + " with direction " + tilesToProcess[0].connection_x + "," + tilesToProcess[0].connection_y);
//Generate a list of rooms that can be used
List <GenerationAreaSettings> validRooms = new List <GenerationAreaSettings>();
//Check which areas can be placed
foreach (GenerationAreaSettings setting in areaData)
{
Direction direction = Direction.NORTH;
if (tilesToProcess[0].connection_x == 1)
{
direction = Direction.WEST;
}
else if (tilesToProcess[0].connection_x == -1)
{
direction = Direction.EAST;
}
else if (tilesToProcess[0].connection_y == 1)
{
direction = Direction.NORTH;
}
else if (tilesToProcess[0].connection_y == -1)
{
direction = Direction.SOUTH;
}
else
{
Log.PrintError("Major error, door direction invalid");
}
validRooms.AddRange(setting.CheckSpace(turfs, tilesToProcess[0].x, tilesToProcess[0].y, direction));
}
//Check weights
//Place it
if (validRooms.Count == 0)
{
tilesToProcess.RemoveAt(0);
continue;
}
GenerationAreaSettings chosenArea = Helpers.Pick(validRooms);
foreach (GenerationTurfSettings tile in chosenArea.generationTurfSettings)
{
//Debug.Log("[" + tile.x + "]" + "[" + tile.y + "] : Added turf, type : [" + tile.type + "]" + (tile.type == "wall").ToString()); //DEBUG, REMOVE WHEN DONE
turfs[tile.x, tile.y].calculated = true;
turfs[tile.x, tile.y].occupied = tile.type == "wall";
turfs[tile.x, tile.y].hasCeiling = tile.type != "sky";
turfs[tile.x, tile.y].hasFloor = tile.type != "pit";
turfs[tile.x, tile.y].turfMesh = objectMesh.sharedMesh;
if (tile.door_dir_x != 0 || tile.door_dir_y != 0)
{
turfs[tile.x, tile.y].door = true;
}
if (tile.door_dir_x != 0 || tile.door_dir_y != 0)
{
TileData data = new TileData();
data.x = tile.x;
data.y = tile.y;
data.connection_x = tile.door_dir_x;
data.connection_y = tile.door_dir_y;
tilesToProcess.Add(data);
//Log.Print("Added new tile to be processed at " + data.x + "," + data.y + "," + data.connection_x + "," + data.connection_y);
}
}
successfulCount++;
tilesToProcess.RemoveAt(0);
}
Log.Print("<color=green>Successfully generated " + roomCount + " rooms, of which " + successfulCount + " were successful</color>");
return(turfs);
}
/// <summary>
/// Calculates the path.
/// We can do it all in 1 go, this system is on a seperate thread so it doesn't matter too much if we take a while.
/// This is probably a pretty ineffecient implementation but its on a seperate thread, gets the job done and isn't too critical for the project.
/// </summary>
/// <param name="request"></param>
public bool CalculatePath(PathfindingRequest request)
{
pathId++;
//The list of nodes that can be searched
//Everything in this list should have updated costs values before going in
//since we don't reset and recaclulate every time so the old path values will
//be carried over otherwise.
List <Node> searchNodes = new List <Node>();
//Cache the end node because its quicker than checking list every time
Node targetNode = worldNodes[request.end_x, request.end_y];
//Calculate initial nodes (The ones adjacent)
SetupInitialConditions(ref searchNodes, request);
//Cool lets just keep searching until we run out of things to search
//If we have to search more than X nodes, just assume its impossible.
int sanity = 20000;
Stopwatch timer = new Stopwatch();
timer.Start();
while (sanity > 0 && searchNodes.Count > 0)
{
sanity--;
//Might be a way with cachine to make this faster, this is quite slow :(
//We could use a sorted list, binary search and insertion in order?#
//Would be tons faster
//(We do all this mini optimisations then have this as super slow!)
int lowestIndex = 0;
float lowestCost = searchNodes[lowestIndex].GetTotalCost();
for (int i = 1; i < searchNodes.Count; i++)
{
float testCost = searchNodes[i].GetTotalCost();
if (testCost < lowestCost)
{
lowestCost = testCost;
lowestIndex = i;
}
}
//We know the node to search now
Node testingNode = searchNodes[lowestIndex];
//Console.WriteLine($"Checking: {testingNode.x}, {testingNode.y} with cost: {testingNode.GetTotalCost()}");
//Have we reached the end?
if (testingNode == targetNode)
{
List <Node> quickestPath = testingNode.GetRecursiveNodes();
List <Turf> pathTurfs = new List <Turf>();
Log.PrintDebug($"Found path length: {quickestPath.Count}");
#if !UNITY_INCLUDE_TESTS
foreach (Node node in quickestPath)
{
Turf locatedBase = LevelGenerator.current.turfs[node.x, node.y];
pathTurfs.Add(locatedBase);
}
#endif
Path finalPath = new Path();
finalPath.calculatedRoute = pathTurfs;
request.CompletePath(finalPath);
timer.Stop();
Log.PrintDebug($"Found path in {timer.ElapsedMilliseconds}ms");
return(true);
}
//Add surrounding nodes
AddSurroundingNodes(ref searchNodes, testingNode, request);
//Block it from being re-added
testingNode.isChecked = true;
//Thats all the checking we needed to do
searchNodes.Remove(testingNode);
}
//No path found
request.FailPath();
Log.PrintDebug("No path was found");
Log.PrintDebug($"Failed to find path in {timer.ElapsedMilliseconds}ms");
return(false);
}
public void CoordEach()
{
var expect = new List <List <double> >()
{
new List <double>()
{
0, 0
}
};
var output = new List <List <double> >();
Action <List <double> > callback = (List <double> obj) => {
output.Add(obj);
};
Turf.CoordEach(pointFeature, callback);
Assert.AreEqual(output, expect);
var pointCollect = Collection(pointFeature);
output.Clear();
Turf.CoordEach(pointCollect, callback);
Assert.AreEqual(output, expect);
expect.Add(new List <double>()
{
1, 1
});
output.Clear();
Turf.CoordEach(lineStringGeometry, callback);
Assert.AreEqual(output, expect);
var lineStringFeature = Feature(lineStringGeometry);
output.Clear();
Turf.CoordEach(lineStringFeature, callback);
Assert.AreEqual(output, expect);
var lineStringCollect = Collection(lineStringFeature);
output.Clear();
Turf.CoordEach(lineStringCollect, callback);
Assert.AreEqual(output, expect);
expect.Add(new List <double>()
{
0, 1
});
output.Clear();
Turf.CoordEach(polygonGeometry, callback, true);
Assert.AreEqual(output, expect);
var polygonFeature = Feature(polygonGeometry);
output.Clear();
Turf.CoordEach(polygonFeature, callback, true);
Assert.AreEqual(output, expect);
var polygonCollect = Collection(polygonFeature);
output.Clear();
Turf.CoordEach(polygonCollect, callback, true);
Assert.AreEqual(output, expect);
expect.Add(new List <double>()
{
0, 0
});
output.Clear();
Turf.CoordEach(polygonGeometry, callback);
Assert.AreEqual(output, expect);
output.Clear();
Turf.CoordEach(polygonFeature, callback);
Assert.AreEqual(output, expect);
output.Clear();
Turf.CoordEach(polygonCollect, callback);
Assert.AreEqual(output, expect);
}
