public static PointD GetForceForBoundry(PointD particle, Polygon bounds)
{
Vector2 point = new Vector2((float)particle.X, (float)particle.Y);
List <KeyValuePair <MathUtil.Pair <float, float>, MathUtil.Pair <Vector2, Vector2> > > edgesWithinDistance = bounds.GetEdgesWithinDistance(point, 3.40282347E+38f);
double num = 0.0;
double num2 = 0.0;
for (int i = 0; i < edgesWithinDistance.Count; i++)
{
KeyValuePair <MathUtil.Pair <float, float>, MathUtil.Pair <Vector2, Vector2> > keyValuePair = edgesWithinDistance[i];
MathUtil.Pair <Vector2, Vector2> value = keyValuePair.Value;
float second = keyValuePair.Key.Second;
double num3 = (double)keyValuePair.Key.First;
Vector2 vector = value.First + (value.Second - value.First) * second;
PointD pointD = new PointD((double)vector.x, (double)vector.y);
double num4 = 1.0 / (num3 * num3);
num += (particle.X - pointD.X) / num3 * num4;
num2 += (particle.Y - pointD.Y) / num3 * num4;
}
if (bounds.Contains(point))
{
return(new PointD(num, num2));
}
return(new PointD(0.0 - num, 0.0 - num2));
}
public float DistanceToClosestEdge(Vector2?point = default(Vector2?))
{
if (!point.HasValue)
{
point = Centroid();
}
float timeOnEdge = 0f;
MathUtil.Pair <Vector2, Vector2> closestEdge = GetClosestEdge(point.Value, ref timeOnEdge);
Vector2 a = closestEdge.Second - closestEdge.First;
Vector2 a2 = closestEdge.First + a * timeOnEdge;
return(Vector2.Distance(a2, point.Value));
}
public Commonality SharesEdgeClosest(Polygon other)
{
Commonality result = Commonality.None;
float timeOnEdge = 0f;
MathUtil.Pair <Vector2, Vector2> closestEdge = GetClosestEdge(other.Centroid(), ref timeOnEdge);
MathUtil.Pair <Vector2, Vector2> closestEdge2 = other.GetClosestEdge(Centroid(), ref timeOnEdge);
if (Vector2.Distance(closestEdge.First, closestEdge2.First) < 1E-05f || Vector2.Distance(closestEdge.First, closestEdge2.Second) < 1E-05f)
{
if (Vector2.Distance(closestEdge.Second, closestEdge2.First) < 1E-05f || Vector2.Distance(closestEdge.Second, closestEdge2.Second) < 1E-05f)
{
return(Commonality.Edge);
}
return(Commonality.Point);
}
return(result);
}
public List <KeyValuePair <MathUtil.Pair <float, float>, MathUtil.Pair <Vector2, Vector2> > > GetEdgesWithinDistance(Vector2 point, float distance = float.MaxValue)
{
List <KeyValuePair <MathUtil.Pair <float, float>, MathUtil.Pair <Vector2, Vector2> > > list = new List <KeyValuePair <MathUtil.Pair <float, float>, MathUtil.Pair <Vector2, Vector2> > >();
float closest_point = 0f;
int index = vertices.Count - 1;
int num = 0;
while (num < vertices.Count)
{
MathUtil.Pair <Vector2, Vector2> pair = new MathUtil.Pair <Vector2, Vector2>(vertices[index], vertices[num]);
MathUtil.Pair <float, float> pair2 = new MathUtil.Pair <float, float>();
float num2 = Mathf.Abs(MathUtil.GetClosestPointBetweenPointAndLineSegment(pair, point, ref closest_point));
if (num2 < distance)
{
pair2.First = num2;
pair2.Second = closest_point;
list.Add(new KeyValuePair <MathUtil.Pair <float, float>, MathUtil.Pair <Vector2, Vector2> >(pair2, pair));
}
index = num++;
}
list.Sort((KeyValuePair <MathUtil.Pair <float, float>, MathUtil.Pair <Vector2, Vector2> > a, KeyValuePair <MathUtil.Pair <float, float>, MathUtil.Pair <Vector2, Vector2> > b) => a.Key.First.CompareTo(b.Key.First));
return(list);
}
public MathUtil.Pair <Vector2, Vector2> GetClosestEdge(Vector2 point, ref float timeOnEdge)
{
MathUtil.Pair <Vector2, Vector2> result = null;
float closest_point = 0f;
timeOnEdge = 0f;
float num = 3.40282347E+38f;
int index = vertices.Count - 1;
int num2 = 0;
while (num2 < vertices.Count)
{
MathUtil.Pair <Vector2, Vector2> pair = new MathUtil.Pair <Vector2, Vector2>(vertices[index], vertices[num2]);
float num3 = Mathf.Abs(MathUtil.GetClosestPointBetweenPointAndLineSegment(pair, point, ref closest_point));
if (num3 < num)
{
num = num3;
result = pair;
timeOnEdge = closest_point;
}
index = num2++;
}
return(result);
}
private void ApplyBackground(WorldGen worldGen, Chunk world, SetValuesFunction SetValues, float temperatureMin, float temperatureRange, SeededRandom rnd)
{
LogInfo("Apply Background", node.type, 0f);
float floatSetting = worldGen.Settings.GetFloatSetting("CaveOverrideMaxValue");
float floatSetting2 = worldGen.Settings.GetFloatSetting("CaveOverrideSliverValue");
Leaf leafForTerrainCell = worldGen.GetLeafForTerrainCell(this);
bool flag = leafForTerrainCell.tags.Contains(WorldGenTags.IgnoreCaveOverride);
bool flag2 = leafForTerrainCell.tags.Contains(WorldGenTags.CaveVoidSliver);
bool flag3 = leafForTerrainCell.tags.Contains(WorldGenTags.ErodePointToCentroid);
bool flag4 = leafForTerrainCell.tags.Contains(WorldGenTags.ErodePointToCentroidInv);
bool flag5 = leafForTerrainCell.tags.Contains(WorldGenTags.ErodePointToEdge);
bool flag6 = leafForTerrainCell.tags.Contains(WorldGenTags.ErodePointToEdgeInv);
bool flag7 = leafForTerrainCell.tags.Contains(WorldGenTags.ErodePointToBorder);
bool flag8 = leafForTerrainCell.tags.Contains(WorldGenTags.ErodePointToBorderInv);
bool flag9 = leafForTerrainCell.tags.Contains(WorldGenTags.ErodePointToWorldTop);
bool flag10 = leafForTerrainCell.tags.Contains(WorldGenTags.DistFunctionPointCentroid);
bool flag11 = leafForTerrainCell.tags.Contains(WorldGenTags.DistFunctionPointEdge);
Sim.DiseaseCell diseaseCell = default(Sim.DiseaseCell);
diseaseCell.diseaseIdx = byte.MaxValue;
if (node.tags.Contains(WorldGenTags.Infected))
{
diseaseCell.diseaseIdx = (byte)rnd.RandomRange(0, WorldGen.diseaseIds.Count);
node.tags.Add(new Tag("Infected:" + WorldGen.diseaseIds[diseaseCell.diseaseIdx]));
diseaseCell.elementCount = rnd.RandomRange(10000, 1000000);
}
LogInfo("Getting Element Bands", node.type, 0f);
ElementBandConfiguration elementBandConfiguration = worldGen.Settings.GetElementBandForBiome(node.type);
if (elementBandConfiguration == null && node.biomeSpecificTags != null)
{
LogInfo("\tType is not a biome, checking tags", string.Empty, (float)node.tags.Count);
List <ElementBandConfiguration> list = new List <ElementBandConfiguration>();
foreach (Tag biomeSpecificTag in node.biomeSpecificTags)
{
ElementBandConfiguration elementBandForBiome = worldGen.Settings.GetElementBandForBiome(biomeSpecificTag.Name);
if (elementBandForBiome != null)
{
list.Add(elementBandForBiome);
LogInfo("\tFound biome", biomeSpecificTag.Name, 0f);
}
}
if (list.Count > 0)
{
int num = rnd.RandomSource().Next(list.Count);
elementBandConfiguration = list[num];
LogInfo("\tPicked biome", string.Empty, (float)num);
}
}
DebugUtil.Assert(elementBandConfiguration != null, "A node didn't get assigned a biome! ", node.type);
foreach (Vector2I availableTerrainPoint in availableTerrainPoints)
{
Vector2I current2 = availableTerrainPoint;
int num2 = Grid.XYToCell(current2.x, current2.y);
if (!highPriorityClaims.Contains(num2))
{
float num3 = world.overrides[num2];
if (!flag && num3 >= 100f)
{
if (num3 >= 300f)
{
SetValues(num2, WorldGen.voidElement, WorldGen.voidElement.defaultValues, Sim.DiseaseCell.Invalid);
}
else if (num3 >= 200f)
{
SetValues(num2, WorldGen.unobtaniumElement, WorldGen.unobtaniumElement.defaultValues, Sim.DiseaseCell.Invalid);
}
else
{
SetValues(num2, WorldGen.katairiteElement, WorldGen.katairiteElement.defaultValues, Sim.DiseaseCell.Invalid);
}
}
else
{
float num4 = 1f;
Vector2 vector = new Vector2((float)current2.x, (float)current2.y);
if (flag3 || flag4)
{
float num5 = 15f;
if (flag11)
{
float timeOnEdge = 0f;
MathUtil.Pair <Vector2, Vector2> closestEdge = poly.GetClosestEdge(vector, ref timeOnEdge);
Vector2 a = closestEdge.First + (closestEdge.Second - closestEdge.First) * timeOnEdge;
num5 = Vector2.Distance(a, vector);
}
num4 = Vector2.Distance(poly.Centroid(), vector) / num5;
num4 = Mathf.Max(0f, Mathf.Min(1f, num4));
if (flag4)
{
num4 = 1f - num4;
}
}
if (flag6 || flag5)
{
float timeOnEdge2 = 0f;
MathUtil.Pair <Vector2, Vector2> closestEdge2 = poly.GetClosestEdge(vector, ref timeOnEdge2);
Vector2 a2 = closestEdge2.First + (closestEdge2.Second - closestEdge2.First) * timeOnEdge2;
float num6 = 15f;
if (flag10)
{
num6 = Vector2.Distance(poly.Centroid(), vector);
}
num4 = Vector2.Distance(a2, vector) / num6;
num4 = Mathf.Max(0f, Mathf.Min(1f, num4));
if (flag6)
{
num4 = 1f - num4;
}
}
if (flag8 || flag7)
{
List <Edge> edgesWithTag = worldGen.WorldLayout.overworldGraph.GetEdgesWithTag(WorldGenTags.EdgeClosed);
float num7 = 3.40282347E+38f;
foreach (Edge item in edgesWithTag)
{
MathUtil.Pair <Vector2, Vector2> segment = new MathUtil.Pair <Vector2, Vector2>(item.corner0.position, item.corner1.position);
float closest_point = 0f;
float a3 = Mathf.Abs(MathUtil.GetClosestPointBetweenPointAndLineSegment(segment, vector, ref closest_point));
num7 = Mathf.Min(a3, num7);
}
float num8 = 7f;
if (flag10)
{
num8 = Vector2.Distance(poly.Centroid(), vector);
}
num4 = num7 / num8;
num4 = Mathf.Max(0f, Mathf.Min(1f, num4));
if (flag8)
{
num4 = 1f - num4;
}
}
if (flag9)
{
Vector2I worldSize = worldGen.WorldSize;
int y = worldSize.y;
float num9 = 38f;
float num10 = 58f;
float num11 = (float)y - vector.y;
num4 = ((num11 < num9) ? 0f : ((!(num11 < num10)) ? 1f : Mathf.Clamp01((num11 - num9) / (num10 - num9))));
}
worldGen.GetElementForBiomePoint(world, elementBandConfiguration, current2, out Element element, out Sim.PhysicsData pd, out Sim.DiseaseCell dc, num4);
if (!element.IsVacuum && element.id != SimHashes.Katairite && element.id != SimHashes.Unobtanium)
{
if (element.lowTempTransition != null && temperatureMin < element.lowTemp)
{
temperatureMin = element.lowTemp + 20f;
}
pd.temperature = temperatureMin + world.heatOffset[num2] * temperatureRange;
}
if (element.IsSolid && !flag && num3 > floatSetting && num3 < 100f)
{
element = ((!flag2 || !(num3 > floatSetting2)) ? WorldGen.vacuumElement : WorldGen.voidElement);
pd = element.defaultValues;
}
if (dc.diseaseIdx == 255)
{
dc = diseaseCell;
}
SetValues(num2, element, pd, dc);
}
}
}
if (node.tags.Contains(WorldGenTags.SprinkleOfOxyRock))
{
HandleSprinkleOfElement(worldGen.Settings, WorldGenTags.SprinkleOfOxyRock, world, SetValues, temperatureMin, temperatureRange, rnd);
}
if (node.tags.Contains(WorldGenTags.SprinkleOfMetal))
{
HandleSprinkleOfElement(worldGen.Settings, WorldGenTags.SprinkleOfMetal, world, SetValues, temperatureMin, temperatureRange, rnd);
}
}
