public GraphNode <T> ChangeTagToPermanent()
{
var node = Neighbours.Where(x => x.Tag[0] == Neighbours.Where(y => y.IsTagPermanent == false).Min(y => y.Tag[0])).First();
node.IsTagPermanent = true;
return(node);
}
/// <inheritdoc />
public IHastingsMemento CreateMemento()
{
var worthyNeighbours = Neighbours.Where(n => n.StateTypes != NeighbourStateTypes.UnResponsive).ToList();
Logger.Debug("Creating new memento with Peer {peer} and neighbours [{neighbours}]",
Peer, string.Join(", ", worthyNeighbours));
return(new HastingsMemento(Peer, new Neighbours(worthyNeighbours)));
}
public List <Territory> GetAttackableNeighbours(bool requireSoldiers = false)
{
if (requireSoldiers && NrOfSoldiers == 1)
{
return(new List <Territory>());
}
return(new List <Territory>(Neighbours.Where(t => t.Owner != this.Owner)));
}
/// <summary>
/// Opens this Tile's neighbours, and maybe their neighbours.
/// </summary>
public void OpenNeighbours()
{
var flags = Neighbours.Where(t => t.HasFlag).Count();
if (flags == Bombs)
{
foreach (var neighbour in Neighbours)
{
if (!neighbour.IsOpen && !neighbour.HasFlag)
{
neighbour.Open();
}
}
}
}
//public void UpdateAlignPlane()
//{
// if (!AlignPlaneDirty)
// return;
// AlignPlaneDirty = false;
// if (AABB.Dimensions.Z < 3 || Neighbours == null)
// {
// AlignPlane = new Plane(AABB.Center, new Vec3(0, 0, 1));
// }
// // special case for single neighbor
// else if (Neighbours.Count == 1)
// {
// if (Neighbours[0].border_segment != null)
// AlignPlane = new Plane(Neighbours[0].border_segment.Item1, Neighbours[0].border_segment.Item2, Center);
// }
// else
// {
// var borders = Neighbours.Where(x => (x.connection_flags & MovementFlag.Walk) != 0 && x.border_segment != null).Select(x => x.border_segment);
// if (borders.Count() == 0)
// {
// AlignPlane = new Plane(AABB.Center, new Vec3(0, 0, 1));
// return;
// }
// // corners starting from min CCW and then from corner above min CCW
// Vec3[] corners = new Vec3[] { AABB.Min, new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Min.Z), new Vec3(AABB.Max.X, AABB.Max.Y, AABB.Min.Z), new Vec3(AABB.Max.X, AABB.Min.Y, AABB.Min.Z),
// new Vec3(AABB.Min.X, AABB.Min.Y, AABB.Max.Z), new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Max.Z), AABB.Max, new Vec3(AABB.Max.X, AABB.Min.Y, AABB.Max.Z) };
// bool[] corner_connected = new bool[8];
// List<int> connected_upper_corners = new List<int>();
// List<int> connected_lower_corners = new List<int>();
// for (int i = 0; i < corners.Count(); ++i)
// {
// corner_connected[i] = borders.FirstOrDefault(x => Vec3.GetDistanceFromSegment(x.Item1, x.Item2, corners[i]) < 2) != null;
// if (corner_connected[i])
// {
// if (i <= 3)
// connected_lower_corners.Add(i);
// else
// {
// connected_upper_corners.Add(i);
// // disable connected corner below this one, as upper corners has priority as there are situations where two stairscases can cross -
// // in this case there might be 4 connected lower corners but only 2 connected upper corners
// connected_lower_corners.RemoveAll(x => x == (i - 4));
// }
// }
// }
// if (connected_lower_corners.Count == 1 && connected_upper_corners.Count == 1)
// {
// // this ain't perfect solution (when those 3 point lineup its non-determined)
// AlignPlane = new Plane(corners[connected_lower_corners[0]], corners[connected_upper_corners[0]], AABB.Center);
// }
// // check upper corners first because
// else if (connected_upper_corners.Count > 1)
// {
// if (connected_lower_corners.Count > 0)
// AlignPlane = new Plane(corners[connected_upper_corners[0]], corners[connected_upper_corners[1]], AABB.Center);
// else
// AlignPlane = new Plane(corners[connected_upper_corners[0]], corners[connected_upper_corners[1]], new Vec3(AABB.Center.X, AABB.Center.Y, AABB.Max.Z));
// }
// else if (connected_lower_corners.Count > 1)
// {
// if (connected_upper_corners.Count > 0)
// AlignPlane = new Plane(corners[connected_lower_corners[0]], corners[connected_lower_corners[1]], AABB.Center);
// else
// AlignPlane = new Plane(corners[connected_lower_corners[0]], corners[connected_lower_corners[1]], new Vec3(AABB.Center.X, AABB.Center.Y, AABB.Min.Z));
// }
// else
// {
// //having 1 or non connected corners i'm unable to determine plane
// //Log("[Nav] Undetermined cell align plane too few corners connected!");
// }
// //Tuple<Vec3, Vec3> longest_border = null;
// //float longest_border_len_2 = 0;
// //foreach (Neighbour n in Neighbours)
// //{
// // if (n.border_segment == null)
// // continue;
// // var border_segment = n.border_segment;
// // float len_2 = border_segment.Item1.Distance2DSqr(border_segment.Item2);
// // if (longest_border == null || longest_border_len_2 < len_2)
// // {
// // longest_border = border_segment;
// // longest_border_len_2 = len_2;
// // }
// //}
// //if (longest_border != null)
// // AlignPlane = new Plane(longest_border.Item1, longest_border.Item2, Center);
// }
//}
public void UpdateAlignPlane()
{
if (!AlignPlaneDirty)
{
return;
}
AlignPlaneDirty = false;
if (AABB.Dimensions.Z < 3 || Neighbours == null)
{
AlignPlane = new Plane(AABB.Center, new Vec3(0, 0, 1));
}
// special case for single neighbor
else if (Neighbours.Count == 1)
{
Vec3 v1 = default(Vec3);
Vec3 v2 = default(Vec3);
if (GetBorderSegmentWith(Neighbours[0].cell.AABB, ref v1, ref v2))
{
AlignPlane = new Plane(v1, v2, Center);
}
}
else
{
// find plane from all possible plane with smallest average distance of all connection points from it
var connect_points = Neighbours.Where(x => (x.connection_flags & MovementFlag.Walk) != 0).Select(x => x.border_point).ToList();
//this is Diablo related hack, as most certainly won't work in general case :(
Plane[] possible_align_planes = null;
if (AABB.Dimensions.X > 30)
{
possible_align_planes = new Plane[] { new Plane(AABB.Min, new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Min.Z), AABB.Center), // bottom-up in direction -X
new Plane(new Vec3(AABB.Min.X, AABB.Min.Y, AABB.Max.Z), new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Max.Z), AABB.Center), // up-bottom in direction -X
new Plane(AABB.Min, new Vec3(0, 0, 1)), //flat bottom
new Plane(AABB.Max, new Vec3(0, 0, 1)) }; // flat up
}
else if (AABB.Dimensions.Y > 30)
{
possible_align_planes = new Plane[] { new Plane(new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Min.Z), new Vec3(AABB.Max.X, AABB.Max.Y, AABB.Min.Z), AABB.Center), // bottom-up in direction Y
new Plane(new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Max.Z), AABB.Max, AABB.Center), // up-bottom in direction Y
new Plane(AABB.Min, new Vec3(0, 0, 1)), //flat bottom
new Plane(AABB.Max, new Vec3(0, 0, 1)) }; // flat up
}
else
{
possible_align_planes = new Plane[] { new Plane(AABB.Min, new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Min.Z), AABB.Center), // bottom-up in direction -X
new Plane(new Vec3(AABB.Min.X, AABB.Min.Y, AABB.Max.Z), new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Max.Z), AABB.Center), // up-bottom in direction -X
new Plane(new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Min.Z), new Vec3(AABB.Max.X, AABB.Max.Y, AABB.Min.Z), AABB.Center), // bottom-up in direction Y
new Plane(new Vec3(AABB.Min.X, AABB.Max.Y, AABB.Max.Z), AABB.Max, AABB.Center), // up-bottom in direction Y
new Plane(AABB.Min, new Vec3(0, 0, 1)), //flat bottom
new Plane(AABB.Max, new Vec3(0, 0, 1)) }; // flat up
}
float min_avg_dist = -1;
foreach (Plane plane in possible_align_planes)
{
float avg_dist = 0;
foreach (Vec3 p in connect_points)
{
avg_dist += plane.Distance(p);
}
avg_dist /= (float)connect_points.Count();
if (avg_dist < min_avg_dist || min_avg_dist < 0)
{
AlignPlane = plane;
min_avg_dist = avg_dist;
}
}
}
}
public int ComputeFlagNumberOfMines()
{
return(Neighbours.Where(x => x.CellState == CellState.Untouched).Count(x => x.CellType == CellType.Mine));
}
/// <summary>
/// get a list of atoms that match an unprocessed criterion
/// </summary>
/// <param name="unprocessedTest">Predicate to test degree of processing -pass as a lambda</param>
/// <returns></returns>
public List <Atom> UnprocessedNeighbours(Predicate <Atom> unprocessedTest)
{
return(Neighbours.Where(a => unprocessedTest(a)).ToList());
}
public List <Atom> NeighboursExcept(params Atom[] toIgnore)
{
return(Neighbours.Where(a => !toIgnore.Contains(a)).ToList());
}
/// <summary>
/// Converts a CML element to a point object
/// </summary>
/// <param name="atom">XEelement describing the atom</param>
/// <returns></returns>
/// <summary>
/// returns all borderign atoms except the one listed
/// </summary>
/// <param name="toIgnore"></param>
/// <returns></returns>
public List <Atom> NeighboursExcept(Atom toIgnore)
{
return(Neighbours.Where(a => a != toIgnore).ToList());
}
public List <Territory> getOwnedNeighbours()
{
return(new List <Territory>(Neighbours.Where(t => t.Owner == this.Owner)));
}