public ResourceReturnHighLevelGoal(Unit owner, TileNodeNetwork nodeNetwork, Building targetReturnBuilding)
{
Owner = owner;
NodeNetwork = nodeNetwork;
ResourceReturnBuilding = targetReturnBuilding;
ResourceReturnBuildingTile = GetSingleTile(ResourceReturnBuilding.Position);
}
internal static void Initialize(Polygon pathing, TileNodeNetwork pathingNodeNetwork)
{
PathingLine = pathing;
NodeNetwork = pathingNodeNetwork;
if (PathingLine != null)
{
UpdatePathingValues();
}
}
private void InitializeNodeNetworks()
{
nodeNetwork = TileNodeNetworkCreator.CreateFromTypes(
Map, DirectionalType.Four, new string[] { "Ground", "Mud" });
// todo - add ground:
//nodeNetwork = new TileNodeNetwork(Map.X, Map.Y - Map.Height, Map.WidthPerTile.Value,
// Map.NumberTilesWide.Value, Map.NumberTilesTall.Value, DirectionalType.Eight);
//nodeNetwork.LinkColor = Microsoft.Xna.Framework.Color.Gray;
//nodeNetwork.NodeColor = Microsoft.Xna.Framework.Color.White;
var names = Map.TileProperties
.Where(item => item.Value.Any(subItem =>
subItem.Name == "Type" &&
((subItem.Value as string) == "Wall" || (subItem.Value as string) == "Pit")))
.Select(item => item.Key)
.ToArray();
var mapHafSize = Map.WidthPerTile.Value / 2.0f;
foreach (var layer in Map.MapLayers)
{
foreach (var name in names)
{
if (layer.NamedTileOrderedIndexes.ContainsKey(name))
{
var indexes = layer.NamedTileOrderedIndexes[name];
foreach (var index in indexes)
{
var bottomLeftPosition = layer.Vertices[index * 4].Position;
var node = nodeNetwork.TiledNodeAtWorld(
bottomLeftPosition.X + mapHafSize,
bottomLeftPosition.Y + mapHafSize);
if (node != null)
{
nodeNetwork.Remove(node);
}
}
}
}
}
if (DebuggingVariables.ShowNodeNetwork)
{
nodeNetwork.Visible = true;
nodeNetwork.UpdateShapes();
}
else
{
nodeNetwork.Visible = false;
}
}
public ResourceCollectHighLevelGoal(Unit owner, TileNodeNetwork nodeNetwork, Vector3 clickPosition, AxisAlignedRectangle targetResourceMergedTile, ResourceType targetResourceType, PositionedObjectList <Building> allBuildings)
{
Owner = owner;
NodeNetwork = nodeNetwork;
TargetResourceMergedTile = targetResourceMergedTile;
TargetResourceType = targetResourceType;
AllBuildings = allBuildings;
// TODO: Handle when we can't get to desired tile (e.g., tree in the middle of forest).
SingleTargetResourceTileCenter = GetSingleTileCenterFromClickPosition(clickPosition);
SingleTargetResourceTile = GetSingleTile(SingleTargetResourceTileCenter);
}
public static void RemoveNodesWithCollisions(ref TileNodeNetwork network,
PositionedObjectList <TileCollisionRectangle> rectangleCollision,
PositionedObjectList <TileCollisionCircle> circleCollision)
{
foreach (var tileCollisionRectangle in rectangleCollision)
{
tileCollisionRectangle.ForceUpdateDependenciesDeep();
}
foreach (var tileCollisionCircle in circleCollision)
{
tileCollisionCircle.ForceUpdateDependenciesDeep();
}
var nodeCircle = new Circle {
Radius = 20f
};
for (var i = network.Nodes.Count - 1; i >= 0; i--)
{
var node = network.Nodes[i];
var nodeRemoved = false;
nodeCircle.Position = node.Position;
if (rectangleCollision.Any(rect => rect.CollideAgainst(nodeCircle)))
{
network.Remove(node);
nodeRemoved = true;
}
if (!nodeRemoved)
{
if (circleCollision.Any(circle => circle.Altitude == 0 && circle.CollideAgainst(nodeCircle)))
{
network.Remove(node);
nodeRemoved = true;
}
}
}
}
public static TileNodeNetwork CreateFromTiledMap(LayeredTileMap map)
{
var costs = new float[32];
costs[(int)NodeType.Normal] = 2;
costs[(int)NodeType.Path] = 1;
const int gridWidth = 64;
var network = new TileNodeNetwork(0, //GridWidth / 2f,
-map.Height, // + GridWidth / 2f,
gridWidth,
MathFunctions.RoundToInt(map.Width / gridWidth),
MathFunctions.RoundToInt(map.Height / gridWidth),
DirectionalType.Eight);
AddNodes(map, "Ground", NodeType.Normal, ref network, gridWidth);
AddNodes(map, "Ground", NodeType.Path, ref network, gridWidth);
network.SetCosts(costs);
return(network);
}
private static void AddNodes(LayeredTileMap map, string layerName, NodeType tileProperty, ref TileNodeNetwork network, int gridWidth)
{
var layer = map.MapLayers.FirstOrDefault(l => l.Name.Equals(layerName));
var tileNamesForPath = map.TileProperties
.Where(item => item.Value
.Any(customProperty => customProperty.Value.Equals(tileProperty.ToString())))
.Select(item => item.Key)
.ToArray();
foreach (var tileName in tileNamesForPath)
{
var indexes = layer != null && layer.NamedTileOrderedIndexes.ContainsKey(tileName)
? layer.NamedTileOrderedIndexes[tileName]
: null;
if (indexes == null)
{
continue;
}
for (var i = indexes.Count - 1; i > -1; i--)
{
var gridIncrement = map.WidthPerTile / gridWidth;
layer.GetBottomLeftWorldCoordinateForOrderedTile(indexes[i], out float x, out float y);
for (var j = 0; j < gridIncrement; j++)
{
for (var k = 0; k < gridIncrement; k++)
{
var node = network.AddAndLinkTiledNodeWorld(x + (gridWidth * j), y + (gridWidth * k));
node.PropertyField = (1 << (int)(tileProperty));
}
}
}
}
}
