public override IEnumerable Regenerate()
{
foreach (object item2 in base.Regenerate())
{
yield return(item2);
}
LayerSubMesh subMesh = GetSubMesh(WorldMaterials.Rivers);
LayerSubMesh subMeshBorder = GetSubMesh(WorldMaterials.RiversBorder);
WorldGrid grid = Find.WorldGrid;
List <OutputDirection> outputs = new List <OutputDirection>();
List <OutputDirection> outputsBorder = new List <OutputDirection>();
int i = 0;
while (i < grid.TilesCount)
{
if (i % 1000 == 0)
{
yield return(null);
}
if (subMesh.verts.Count > 60000)
{
subMesh = GetSubMesh(WorldMaterials.Rivers);
subMeshBorder = GetSubMesh(WorldMaterials.RiversBorder);
}
Tile tile = grid[i];
if (tile.potentialRivers != null)
{
outputs.Clear();
outputsBorder.Clear();
for (int j = 0; j < tile.potentialRivers.Count; j++)
{
OutputDirection item = new OutputDirection
{
neighbor = tile.potentialRivers[j].neighbor,
width = tile.potentialRivers[j].river.widthOnWorld - 0.2f
};
outputs.Add(item);
item = new OutputDirection
{
neighbor = tile.potentialRivers[j].neighbor,
width = tile.potentialRivers[j].river.widthOnWorld
};
outputsBorder.Add(item);
}
GeneratePaths(subMesh, i, outputs, riverColor, allowSmoothTransition: true);
GeneratePaths(subMeshBorder, i, outputsBorder, riverColor, allowSmoothTransition: true);
}
int num = i + 1;
i = num;
}
FinalizeMesh(MeshParts.All);
}
private void AddPathEndpoint(LayerSubMesh subMesh, List <Vector3> verts, int index, Color32 color, int tileID, OutputDirection data)
{
int index2 = (index + 1) % verts.Count;
Find.WorldGrid.GetTileNeighbors(tileID, lhsID);
Find.WorldGrid.GetTileNeighbors(data.neighbor, rhsID);
float num = lhsID.Intersect(rhsID).Any((int id) => Find.WorldGrid[id].WaterCovered) ? 0.5f : 1f;
Vector3 a = FinalizePoint(verts[index], data.distortionFrequency, data.distortionIntensity * num);
Vector3 b = FinalizePoint(verts[index2], data.distortionFrequency, data.distortionIntensity * num);
subMesh.verts.Add(Vector3.LerpUnclamped(a, b, 0.5f - data.width));
subMesh.colors.Add(color.MutateAlpha(0));
subMesh.verts.Add(Vector3.LerpUnclamped(a, b, 0.5f));
subMesh.colors.Add(color);
subMesh.verts.Add(Vector3.LerpUnclamped(a, b, 0.5f + data.width));
subMesh.colors.Add(color.MutateAlpha(0));
}
public override IEnumerable Regenerate()
{
IEnumerator enumerator = base.Regenerate().GetEnumerator();
try
{
if (enumerator.MoveNext())
{
object result = enumerator.Current;
yield return(result);
/*Error: Unable to find new state assignment for yield return*/;
}
}
finally
{
IDisposable disposable;
IDisposable disposable2 = disposable = (enumerator as IDisposable);
if (disposable != null)
{
disposable2.Dispose();
}
}
LayerSubMesh subMesh = base.GetSubMesh(WorldMaterials.Roads);
WorldGrid grid = Find.WorldGrid;
List <RoadWorldLayerDef> roadLayerDefs = (from rwld in DefDatabase <RoadWorldLayerDef> .AllDefs
orderby rwld.order
select rwld).ToList();
for (int i = 0; i < grid.TilesCount; i++)
{
if (i % 1000 == 0)
{
yield return((object)null);
/*Error: Unable to find new state assignment for yield return*/;
}
if (subMesh.verts.Count > 60000)
{
subMesh = base.GetSubMesh(WorldMaterials.Roads);
}
Tile tile = grid[i];
if (!tile.WaterCovered)
{
List <OutputDirection> outputs = new List <OutputDirection>();
if (tile.roads != null)
{
bool allowSmoothTransition = true;
for (int j = 0; j < tile.roads.Count - 1; j++)
{
Tile.RoadLink roadLink = tile.roads[j];
string worldTransitionGroup = roadLink.road.worldTransitionGroup;
Tile.RoadLink roadLink2 = tile.roads[j + 1];
if (worldTransitionGroup != roadLink2.road.worldTransitionGroup)
{
allowSmoothTransition = false;
}
}
for (int k = 0; k < roadLayerDefs.Count; k++)
{
bool flag = false;
outputs.Clear();
for (int l = 0; l < tile.roads.Count; l++)
{
Tile.RoadLink roadLink3 = tile.roads[l];
RoadDef road = roadLink3.road;
float layerWidth = road.GetLayerWidth(roadLayerDefs[k]);
if (layerWidth > 0.0)
{
flag = true;
}
List <OutputDirection> list = outputs;
OutputDirection item = default(OutputDirection);
Tile.RoadLink roadLink4 = tile.roads[l];
item.neighbor = roadLink4.neighbor;
item.width = layerWidth;
item.distortionFrequency = road.distortionFrequency;
item.distortionIntensity = road.distortionIntensity;
list.Add(item);
}
if (flag)
{
base.GeneratePaths(subMesh, i, outputs, roadLayerDefs[k].color, allowSmoothTransition);
}
}
}
}
}
base.FinalizeMesh(MeshParts.All);
yield break;
IL_03a2:
/*Error near IL_03a3: Unexpected return in MoveNext()*/;
}
public void GeneratePaths(LayerSubMesh subMesh, int tileID, List <OutputDirection> nodes, Color32 color, bool allowSmoothTransition)
{
WorldGrid worldGrid = Find.WorldGrid;
worldGrid.GetTileVertices(tileID, tmpVerts);
worldGrid.GetTileNeighbors(tileID, tmpNeighbors);
if (nodes.Count == 1 && pointyEnds)
{
int count = subMesh.verts.Count;
List <Vector3> verts = tmpVerts;
List <int> list = tmpNeighbors;
OutputDirection outputDirection = nodes[0];
AddPathEndpoint(subMesh, verts, list.IndexOf(outputDirection.neighbor), color, tileID, nodes[0]);
List <Vector3> verts2 = subMesh.verts;
Vector3 tileCenter = worldGrid.GetTileCenter(tileID);
OutputDirection outputDirection2 = nodes[0];
float distortionFrequency = outputDirection2.distortionFrequency;
OutputDirection outputDirection3 = nodes[0];
verts2.Add(FinalizePoint(tileCenter, distortionFrequency, outputDirection3.distortionIntensity));
subMesh.colors.Add(color.MutateAlpha(0));
subMesh.tris.Add(count);
subMesh.tris.Add(count + 3);
subMesh.tris.Add(count + 1);
subMesh.tris.Add(count + 1);
subMesh.tris.Add(count + 3);
subMesh.tris.Add(count + 2);
}
else
{
if (nodes.Count == 2)
{
int count2 = subMesh.verts.Count;
List <int> list2 = tmpNeighbors;
OutputDirection outputDirection4 = nodes[0];
int num = list2.IndexOf(outputDirection4.neighbor);
List <int> list3 = tmpNeighbors;
OutputDirection outputDirection5 = nodes[1];
int num2 = list3.IndexOf(outputDirection5.neighbor);
if (allowSmoothTransition && Mathf.Abs(num - num2) > 1 && Mathf.Abs((num - num2 + tmpVerts.Count) % tmpVerts.Count) > 1)
{
AddPathEndpoint(subMesh, tmpVerts, num, color, tileID, nodes[0]);
AddPathEndpoint(subMesh, tmpVerts, num2, color, tileID, nodes[1]);
subMesh.tris.Add(count2);
subMesh.tris.Add(count2 + 5);
subMesh.tris.Add(count2 + 1);
subMesh.tris.Add(count2 + 5);
subMesh.tris.Add(count2 + 4);
subMesh.tris.Add(count2 + 1);
subMesh.tris.Add(count2 + 1);
subMesh.tris.Add(count2 + 4);
subMesh.tris.Add(count2 + 2);
subMesh.tris.Add(count2 + 4);
subMesh.tris.Add(count2 + 3);
subMesh.tris.Add(count2 + 2);
return;
}
}
float num3 = 0f;
for (int i = 0; i < nodes.Count; i++)
{
float a = num3;
OutputDirection outputDirection6 = nodes[i];
num3 = Mathf.Max(a, outputDirection6.width);
}
Vector3 tileCenter2 = worldGrid.GetTileCenter(tileID);
tmpHexVerts.Clear();
for (int j = 0; j < tmpVerts.Count; j++)
{
tmpHexVerts.Add(FinalizePoint(Vector3.LerpUnclamped(tileCenter2, tmpVerts[j], num3 * 0.5f * 2f), 0f, 0f));
}
tileCenter2 = FinalizePoint(tileCenter2, 0f, 0f);
int count3 = subMesh.verts.Count;
subMesh.verts.Add(tileCenter2);
subMesh.colors.Add(color);
int count4 = subMesh.verts.Count;
for (int k = 0; k < tmpHexVerts.Count; k++)
{
subMesh.verts.Add(tmpHexVerts[k]);
subMesh.colors.Add(color.MutateAlpha(0));
subMesh.tris.Add(count3);
subMesh.tris.Add(count4 + (k + 1) % tmpHexVerts.Count);
subMesh.tris.Add(count4 + k);
}
for (int l = 0; l < nodes.Count; l++)
{
OutputDirection outputDirection7 = nodes[l];
if (outputDirection7.width != 0f)
{
int count5 = subMesh.verts.Count;
List <int> list4 = tmpNeighbors;
OutputDirection outputDirection8 = nodes[l];
int num4 = list4.IndexOf(outputDirection8.neighbor);
AddPathEndpoint(subMesh, tmpVerts, num4, color, tileID, nodes[l]);
subMesh.tris.Add(count5);
subMesh.tris.Add(count4 + (num4 + tmpHexVerts.Count - 1) % tmpHexVerts.Count);
subMesh.tris.Add(count3);
subMesh.tris.Add(count5);
subMesh.tris.Add(count3);
subMesh.tris.Add(count5 + 1);
subMesh.tris.Add(count5 + 1);
subMesh.tris.Add(count3);
subMesh.tris.Add(count5 + 2);
subMesh.tris.Add(count3);
subMesh.tris.Add(count4 + (num4 + 2) % tmpHexVerts.Count);
subMesh.tris.Add(count5 + 2);
}
}
}
}
public override IEnumerable Regenerate()
{
IEnumerator enumerator = base.Regenerate().GetEnumerator();
try
{
if (enumerator.MoveNext())
{
object result = enumerator.Current;
yield return(result);
/*Error: Unable to find new state assignment for yield return*/;
}
}
finally
{
IDisposable disposable;
IDisposable disposable2 = disposable = (enumerator as IDisposable);
if (disposable != null)
{
disposable2.Dispose();
}
}
LayerSubMesh subMesh = base.GetSubMesh(WorldMaterials.Rivers);
LayerSubMesh subMeshBorder = base.GetSubMesh(WorldMaterials.RiversBorder);
WorldGrid grid = Find.WorldGrid;
List <OutputDirection> outputs = new List <OutputDirection>();
List <OutputDirection> outputsBorder = new List <OutputDirection>();
for (int i = 0; i < grid.TilesCount; i++)
{
if (i % 1000 == 0)
{
yield return((object)null);
/*Error: Unable to find new state assignment for yield return*/;
}
if (subMesh.verts.Count > 60000)
{
subMesh = base.GetSubMesh(WorldMaterials.Rivers);
subMeshBorder = base.GetSubMesh(WorldMaterials.RiversBorder);
}
Tile tile = grid[i];
if (tile.rivers != null)
{
outputs.Clear();
outputsBorder.Clear();
for (int j = 0; j < tile.rivers.Count; j++)
{
List <OutputDirection> list = outputs;
OutputDirection item = default(OutputDirection);
Tile.RiverLink riverLink = tile.rivers[j];
item.neighbor = riverLink.neighbor;
Tile.RiverLink riverLink2 = tile.rivers[j];
item.width = (float)(riverLink2.river.widthOnWorld - 0.20000000298023224);
list.Add(item);
List <OutputDirection> list2 = outputsBorder;
OutputDirection item2 = default(OutputDirection);
Tile.RiverLink riverLink3 = tile.rivers[j];
item2.neighbor = riverLink3.neighbor;
Tile.RiverLink riverLink4 = tile.rivers[j];
item2.width = riverLink4.river.widthOnWorld;
list2.Add(item2);
}
base.GeneratePaths(subMesh, i, outputs, this.riverColor, true);
base.GeneratePaths(subMeshBorder, i, outputsBorder, this.riverColor, true);
}
}
base.FinalizeMesh(MeshParts.All);
yield break;
IL_0335:
/*Error near IL_0336: Unexpected return in MoveNext()*/;
}
private void AddPathEndpoint(LayerSubMesh subMesh, List <Vector3> verts, int index, Color32 color, OutputDirection data)
{
int index2 = (index + 1) % verts.Count;
Vector3 a = this.FinalizePoint(verts[index], data.distortionFrequency, data.distortionIntensity);
Vector3 b = this.FinalizePoint(verts[index2], data.distortionFrequency, data.distortionIntensity);
subMesh.verts.Add(Vector3.LerpUnclamped(a, b, (float)(0.5 - data.width)));
subMesh.colors.Add(color.MutateAlpha(0));
subMesh.verts.Add(Vector3.LerpUnclamped(a, b, 0.5f));
subMesh.colors.Add(color);
subMesh.verts.Add(Vector3.LerpUnclamped(a, b, (float)(0.5 + data.width)));
subMesh.colors.Add(color.MutateAlpha(0));
}
