private void CreateHousingWaypoint(int housingID, GameObject objRoot, Vector3 areaSize)
{
if (Object.op_Equality((Object)objRoot, (Object)null) || !Singleton <Resources> .IsInstance())
{
return;
}
LocomotionProfile locomotionProfile = Singleton <Resources> .Instance.LocomotionProfile;
if (Object.op_Equality((Object)locomotionProfile, (Object)null))
{
return;
}
List <ValueTuple <Vector3, Waypoint> > waypointList;
if (!this._housingWaypointCacheTable.TryGetValue(housingID, out waypointList) || waypointList == null)
{
this._housingWaypointCacheTable[housingID] = waypointList = new List <ValueTuple <Vector3, Waypoint> >();
Transform transform = objRoot.get_transform();
if (Object.op_Equality((Object)transform, (Object)null))
{
return;
}
float installationDistance = locomotionProfile.HousingWaypointSetting.InstallationDistance;
float installationHeight = locomotionProfile.HousingWaypointSetting.InstallationHeight;
SpiralPoint spiralPoint = new SpiralPoint(999);
for (int index = 0; (double)installationHeight * (double)index < areaSize.y; ++index)
{
float num = installationHeight * (float)index;
spiralPoint.Clear();
spiralPoint.Limit = 999;
while (!spiralPoint.End)
{
Vector3 vector3 = Vector3.op_Multiply(new Vector3((float)((Vector2Int) ref spiralPoint.Current).get_x(), 0.0f, (float)((Vector2Int) ref spiralPoint.Current).get_y()), installationDistance);
vector3.y = (__Null)(double)num;
if (areaSize.y > vector3.y && vector3.x > -areaSize.x / 2.0 && (areaSize.x / 2.0 > vector3.x && vector3.z > -areaSize.z / 2.0) && areaSize.z / 2.0 > vector3.z)
{
vector3 = Vector3.op_Addition(transform.get_position(), Quaternion.op_Multiply(transform.get_rotation(), vector3));
waypointList.Add(new ValueTuple <Vector3, Waypoint>(vector3, (Waypoint)null));
spiralPoint.Next();
}
else
{
break;
}
}
}
}
this.RefreshWaypoints(housingID, waypointList);
}
public static int ManhattanDistance(this SpiralPoint point)
{
return(Math.Abs(point.X) + Math.Abs(point.Y));
}
public static IEnumerable <SpiralPoint> AdjacentSpiral()
{
var cache = new Dictionary <(int, int), SpiralPoint>();
IEnumerable <SpiralPoint> GetNeighbors(int xAxis, int yAxis)
{
var neighbors = new List <SpiralPoint>();
for (var i = -1; i <= 1; i++)
{
for (var j = -1; j <= 1; j++)
{
if (cache.TryGetValue((xAxis + i, yAxis + j), out var neighbor))
{
neighbors.Add(neighbor);
}
}
}
return(neighbors);
}
var value = 0;
var x = 0;
var y = 0;
var direction = Directions().GetEnumerator();
while (direction.Current != Direction.East)
{
direction.MoveNext();
}
var armNumber = ArmDistance().GetEnumerator();
armNumber.MoveNext();
var distanceTraveled = 0;
for (; ;)
{
value = Math.Max(GetNeighbors(x, y).Sum(n => n.Value), 1);
var point = new SpiralPoint(value, x, y);
cache.Add((x, y), point);
yield return(point);
if (distanceTraveled == armNumber.Current)
{
distanceTraveled = 0;
armNumber.MoveNext();
direction.MoveNext();
}
distanceTraveled++;
switch (direction.Current)
{
case Direction.East:
x++;
break;
case Direction.North:
y++;
break;
case Direction.West:
x--;
break;
case Direction.South:
y--;
break;
}
}
}
public SpiralPoint FindNext(int numberToSeek)
{
var spiral = new SpiralPoint()
{
Value = 1
};
var spiralPoints = new List <SpiralPoint>();
Func <int, int, int> getPointValue = (x, y) =>
{
return(spiralPoints.SingleOrDefault(p => p.X == x && p.Y == y)?.Value ?? 0);
};
Func <SpiralPoint, SpiralPoint> next = thisPoint =>
{
spiralPoints.Add(thisPoint);
var xValues = spiralPoints.Select(p => p.X).ToList();
var yValues = spiralPoints.Select(p => p.Y).ToList();
var maxX = xValues.Max();
var maxY = yValues.Max();
var minX = xValues.Min();
var minY = yValues.Min();
var goingUp = maxX.AbsGreaterThan(maxY, minY, minX);
var goingLeft = maxY.AbsGreaterThan(minY, minX) && maxY == maxX;
var goingDown = Day3Helpers.AbsEqual(minX, maxX) && !Day3Helpers.AbsEqual(minX, minY);
var goingRight = Day3Helpers.AbsEqual(minY, minX) && Math.Abs(minY) == Math.Abs(maxX);
var nextPoint = new SpiralPoint()
{
X = thisPoint.X,
Y = thisPoint.Y
};
if (goingDown)
{
nextPoint.Y--;
}
if (goingUp)
{
nextPoint.Y++;
}
if (goingRight)
{
nextPoint.X++;
}
if (goingLeft)
{
nextPoint.X--;
}
thisPoint.Next = nextPoint;
nextPoint.Previous = thisPoint;
var right = getPointValue(nextPoint.X + 1, nextPoint.Y);
var topRight = getPointValue(nextPoint.X + 1, nextPoint.Y + 1);
var top = getPointValue(nextPoint.X, nextPoint.Y + 1);
var topLeft = getPointValue(nextPoint.X - 1, nextPoint.Y + 1);
var left = getPointValue(nextPoint.X - 1, nextPoint.Y);
var bottomLeft = getPointValue(nextPoint.X - 1, nextPoint.Y - 1);
var bottom = getPointValue(nextPoint.X, nextPoint.Y - 1);
var bottomRight = getPointValue(nextPoint.X + 1, nextPoint.Y - 1);
var nextValue = right + topRight + top + topLeft + left + bottomLeft + bottom + bottomRight;
nextPoint.Value = nextValue;
return(nextPoint);
};
var spiralPoint = spiral;
while (spiralPoint.Value <= numberToSeek)
{
spiralPoint = next(spiralPoint);
}
return(spiralPoint);
}
