public float GetRoadMovementDifficultyMultiplier(int fromTile, int toTile, StringBuilder explanation = null)
{
List <Tile.RoadLink> roads = tiles[fromTile].Roads;
if (roads == null)
{
return(1f);
}
if (toTile == -1)
{
toTile = FindMostReasonableAdjacentTileForDisplayedPathCost(fromTile);
}
for (int i = 0; i < roads.Count; i++)
{
Tile.RoadLink roadLink = roads[i];
if (roadLink.neighbor == toTile)
{
Tile.RoadLink roadLink2 = roads[i];
float movementCostMultiplier = roadLink2.road.movementCostMultiplier;
if (explanation != null)
{
if (explanation.Length > 0)
{
explanation.AppendLine();
}
Tile.RoadLink roadLink3 = roads[i];
explanation.Append(roadLink3.road.LabelCap + ": " + movementCostMultiplier.ToStringPercent());
}
return(movementCostMultiplier);
}
}
return(1f);
}
public RoadDef GetRoadDef(int fromTile, int toTile, bool visibleOnly = true)
{
if (!IsNeighbor(fromTile, toTile))
{
Log.ErrorOnce("Tried to find road information between non-neighboring tiles", 12390444);
return(null);
}
Tile tile = tiles[fromTile];
List <Tile.RoadLink> list = (!visibleOnly) ? tile.potentialRoads : tile.Roads;
if (list == null)
{
return(null);
}
for (int i = 0; i < list.Count; i++)
{
Tile.RoadLink roadLink = list[i];
if (roadLink.neighbor == toTile)
{
Tile.RoadLink roadLink2 = list[i];
return(roadLink2.road);
}
}
return(null);
}
public static int RandomBestExitTileFrom(Map map)
{
Tile tile = map.TileInfo;
List <int> options = CaravanExitMapUtility.AvailableExitTilesAt(map);
if (!options.Any())
{
return(-1);
}
if (tile.roads == null)
{
return(options.RandomElement());
}
int bestRoadIndex = -1;
for (int i = 0; i < tile.roads.Count; i++)
{
List <int> list = options;
Tile.RoadLink roadLink = tile.roads[i];
if (list.Contains(roadLink.neighbor))
{
if (bestRoadIndex == -1)
{
goto IL_00e9;
}
Tile.RoadLink roadLink2 = tile.roads[i];
int priority = roadLink2.road.priority;
Tile.RoadLink roadLink3 = tile.roads[bestRoadIndex];
if (priority > roadLink3.road.priority)
{
goto IL_00e9;
}
}
continue;
IL_00e9:
bestRoadIndex = i;
}
if (bestRoadIndex == -1)
{
return(options.RandomElement());
}
Tile.RoadLink roadLink4 = tile.roads.Where(delegate(Tile.RoadLink rl)
{
int result;
if (options.Contains(rl.neighbor))
{
RoadDef road = rl.road;
Tile.RoadLink roadLink5 = tile.roads[bestRoadIndex];
result = ((road == roadLink5.road) ? 1 : 0);
}
else
{
result = 0;
}
return((byte)result != 0);
}).RandomElement();
return(roadLink4.neighbor);
}
public void OverlayRoad(int fromTile, int toTile, RoadDef roadDef)
{
if (roadDef == null)
{
Log.ErrorOnce("Attempted to remove road with overlayRoad; not supported", 90292249);
return;
}
RoadDef roadDef2 = GetRoadDef(fromTile, toTile, visibleOnly: false);
if (roadDef2 == roadDef)
{
return;
}
Tile tile = this[fromTile];
Tile tile2 = this[toTile];
if (roadDef2 != null)
{
if (roadDef2.priority >= roadDef.priority)
{
return;
}
tile.potentialRoads.RemoveAll((Tile.RoadLink rl) => rl.neighbor == toTile);
tile2.potentialRoads.RemoveAll((Tile.RoadLink rl) => rl.neighbor == fromTile);
}
if (tile.potentialRoads == null)
{
tile.potentialRoads = new List <Tile.RoadLink>();
}
if (tile2.potentialRoads == null)
{
tile2.potentialRoads = new List <Tile.RoadLink>();
}
List <Tile.RoadLink> potentialRoads = tile.potentialRoads;
Tile.RoadLink item = new Tile.RoadLink
{
neighbor = toTile,
road = roadDef
};
potentialRoads.Add(item);
List <Tile.RoadLink> potentialRoads2 = tile2.potentialRoads;
item = new Tile.RoadLink
{
neighbor = fromTile,
road = roadDef
};
potentialRoads2.Add(item);
}
public float GetRoadMovementMultiplierFast(int fromTile, int toTile)
{
List <Tile.RoadLink> roads = this.tiles[fromTile].roads;
if (roads == null)
{
return(1f);
}
for (int i = 0; i < roads.Count; i++)
{
Tile.RoadLink roadLink = roads[i];
if (roadLink.neighbor == toTile)
{
Tile.RoadLink roadLink2 = roads[i];
return(roadLink2.road.movementCostMultiplier);
}
}
return(1f);
}
public int FindMostReasonableAdjacentTileForDisplayedPathCost(int fromTile)
{
Tile tile = tiles[fromTile];
float num = 1f;
int num2 = -1;
List <Tile.RoadLink> roads = tile.Roads;
if (roads != null)
{
for (int i = 0; i < roads.Count; i++)
{
Tile.RoadLink roadLink = roads[i];
float movementCostMultiplier = roadLink.road.movementCostMultiplier;
if (movementCostMultiplier < num)
{
World world = Find.World;
Tile.RoadLink roadLink2 = roads[i];
if (!world.Impassable(roadLink2.neighbor))
{
num = movementCostMultiplier;
Tile.RoadLink roadLink3 = roads[i];
num2 = roadLink3.neighbor;
}
}
}
}
if (num2 != -1)
{
return(num2);
}
tmpNeighbors.Clear();
GetTileNeighbors(fromTile, tmpNeighbors);
for (int j = 0; j < tmpNeighbors.Count; j++)
{
if (!Find.World.Impassable(tmpNeighbors[j]))
{
return(tmpNeighbors[j]);
}
}
return(fromTile);
}
public static int CostToDisplay(Caravan caravan, int start, int end, float yearPercent = -1f)
{
if (start != end && end != -1)
{
return(Caravan_PathFollower.CostToMove(caravan.TicksPerMove, start, end, yearPercent));
}
int ticksPerMove = caravan.TicksPerMove;
ticksPerMove += WorldPathGrid.CalculatedCostAt(start, false, yearPercent);
Tile tile = Find.WorldGrid[start];
float num = 1f;
if (tile.roads != null)
{
for (int i = 0; i < tile.roads.Count; i++)
{
float a = num;
Tile.RoadLink roadLink = tile.roads[i];
num = Mathf.Min(a, roadLink.road.movementCostMultiplier);
}
}
return(Mathf.RoundToInt((float)ticksPerMove * num));
}
internal bool <> m__1(Tile.RoadLink rl)
{
return(rl.neighbor == this.fromTile);
}
internal bool <> m__0(Tile.RoadLink rl)
{
return(rl.neighbor == this.toTile);
}
private void TilesToRawData()
{
this.tileBiome = DataSerializeUtility.SerializeUshort(this.TilesCount, (int i) => this.tiles[i].biome.shortHash);
this.tileElevation = DataSerializeUtility.SerializeUshort(this.TilesCount, (int i) => (ushort)Mathf.Clamp(Mathf.RoundToInt(((!this.tiles[i].WaterCovered) ? Mathf.Max(this.tiles[i].elevation, 1f) : this.tiles[i].elevation) + 8192f), 0, 65535));
this.tileHilliness = DataSerializeUtility.SerializeByte(this.TilesCount, (int i) => (byte)this.tiles[i].hilliness);
this.tileTemperature = DataSerializeUtility.SerializeUshort(this.TilesCount, (int i) => (ushort)Mathf.Clamp(Mathf.RoundToInt((this.tiles[i].temperature + 300f) * 10f), 0, 65535));
this.tileRainfall = DataSerializeUtility.SerializeUshort(this.TilesCount, (int i) => (ushort)Mathf.Clamp(Mathf.RoundToInt(this.tiles[i].rainfall), 0, 65535));
this.tileSwampiness = DataSerializeUtility.SerializeByte(this.TilesCount, (int i) => (byte)Mathf.Clamp(Mathf.RoundToInt(this.tiles[i].swampiness * 255f), 0, 255));
this.tileFeature = DataSerializeUtility.SerializeUshort(this.TilesCount, (int i) => (this.tiles[i].feature != null) ? ((ushort)this.tiles[i].feature.uniqueID) : ushort.MaxValue);
List <int> list = new List <int>();
List <byte> list2 = new List <byte>();
List <ushort> list3 = new List <ushort>();
for (int m = 0; m < this.TilesCount; m++)
{
List <Tile.RoadLink> potentialRoads = this.tiles[m].potentialRoads;
if (potentialRoads != null)
{
for (int j = 0; j < potentialRoads.Count; j++)
{
Tile.RoadLink roadLink = potentialRoads[j];
if (roadLink.neighbor >= m)
{
byte b = (byte)this.GetNeighborId(m, roadLink.neighbor);
if (b < 0)
{
Log.ErrorOnce("Couldn't find valid neighbor for road piece", 81637014, false);
}
else
{
list.Add(m);
list2.Add(b);
list3.Add(roadLink.road.shortHash);
}
}
}
}
}
this.tileRoadOrigins = DataSerializeUtility.SerializeInt(list.ToArray());
this.tileRoadAdjacency = DataSerializeUtility.SerializeByte(list2.ToArray());
this.tileRoadDef = DataSerializeUtility.SerializeUshort(list3.ToArray());
List <int> list4 = new List <int>();
List <byte> list5 = new List <byte>();
List <ushort> list6 = new List <ushort>();
for (int k = 0; k < this.TilesCount; k++)
{
List <Tile.RiverLink> potentialRivers = this.tiles[k].potentialRivers;
if (potentialRivers != null)
{
for (int l = 0; l < potentialRivers.Count; l++)
{
Tile.RiverLink riverLink = potentialRivers[l];
if (riverLink.neighbor >= k)
{
byte b2 = (byte)this.GetNeighborId(k, riverLink.neighbor);
if (b2 < 0)
{
Log.ErrorOnce("Couldn't find valid neighbor for river piece", 81637014, false);
}
else
{
list4.Add(k);
list5.Add(b2);
list6.Add(riverLink.river.shortHash);
}
}
}
}
}
this.tileRiverOrigins = DataSerializeUtility.SerializeInt(list4.ToArray());
this.tileRiverAdjacency = DataSerializeUtility.SerializeByte(list5.ToArray());
this.tileRiverDef = DataSerializeUtility.SerializeUshort(list6.ToArray());
}
private static string <FillTab> m__0(Tile.RoadLink roadlink)
{
return(roadlink.road.label);
}
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()*/;
}
private static RoadDef <get_TileInspectString> m__0(Tile.RoadLink rl)
{
return(rl.road);
}
private void RawDataToTiles()
{
if (tiles.Count != TilesCount)
{
tiles.Clear();
for (int j = 0; j < TilesCount; j++)
{
tiles.Add(new Tile());
}
}
else
{
for (int k = 0; k < TilesCount; k++)
{
tiles[k].potentialRoads = null;
tiles[k].potentialRivers = null;
}
}
DataSerializeUtility.LoadUshort(tileBiome, TilesCount, delegate(int i, ushort data)
{
tiles[i].biome = DefDatabase <BiomeDef> .GetByShortHash(data) ?? BiomeDefOf.TemperateForest;
});
DataSerializeUtility.LoadUshort(tileElevation, TilesCount, delegate(int i, ushort data)
{
tiles[i].elevation = data - 8192;
});
DataSerializeUtility.LoadByte(tileHilliness, TilesCount, delegate(int i, byte data)
{
tiles[i].hilliness = (Hilliness)data;
});
DataSerializeUtility.LoadUshort(tileTemperature, TilesCount, delegate(int i, ushort data)
{
tiles[i].temperature = (float)(int)data / 10f - 300f;
});
DataSerializeUtility.LoadUshort(tileRainfall, TilesCount, delegate(int i, ushort data)
{
tiles[i].rainfall = (int)data;
});
DataSerializeUtility.LoadByte(tileSwampiness, TilesCount, delegate(int i, byte data)
{
tiles[i].swampiness = (float)(int)data / 255f;
});
int[] array = DataSerializeUtility.DeserializeInt(tileRoadOrigins);
byte[] array2 = DataSerializeUtility.DeserializeByte(tileRoadAdjacency);
ushort[] array3 = DataSerializeUtility.DeserializeUshort(tileRoadDef);
for (int l = 0; l < array.Length; l++)
{
int num = array[l];
int tileNeighbor = GetTileNeighbor(num, array2[l]);
RoadDef byShortHash = DefDatabase <RoadDef> .GetByShortHash(array3[l]);
if (byShortHash != null)
{
if (tiles[num].potentialRoads == null)
{
tiles[num].potentialRoads = new List <Tile.RoadLink>();
}
if (tiles[tileNeighbor].potentialRoads == null)
{
tiles[tileNeighbor].potentialRoads = new List <Tile.RoadLink>();
}
List <Tile.RoadLink> potentialRoads = tiles[num].potentialRoads;
Tile.RoadLink item = new Tile.RoadLink
{
neighbor = tileNeighbor,
road = byShortHash
};
potentialRoads.Add(item);
List <Tile.RoadLink> potentialRoads2 = tiles[tileNeighbor].potentialRoads;
item = new Tile.RoadLink
{
neighbor = num,
road = byShortHash
};
potentialRoads2.Add(item);
}
}
int[] array4 = DataSerializeUtility.DeserializeInt(tileRiverOrigins);
byte[] array5 = DataSerializeUtility.DeserializeByte(tileRiverAdjacency);
ushort[] array6 = DataSerializeUtility.DeserializeUshort(tileRiverDef);
for (int m = 0; m < array4.Length; m++)
{
int num2 = array4[m];
int tileNeighbor2 = GetTileNeighbor(num2, array5[m]);
RiverDef byShortHash2 = DefDatabase <RiverDef> .GetByShortHash(array6[m]);
if (byShortHash2 != null)
{
if (tiles[num2].potentialRivers == null)
{
tiles[num2].potentialRivers = new List <Tile.RiverLink>();
}
if (tiles[tileNeighbor2].potentialRivers == null)
{
tiles[tileNeighbor2].potentialRivers = new List <Tile.RiverLink>();
}
List <Tile.RiverLink> potentialRivers = tiles[num2].potentialRivers;
Tile.RiverLink item2 = new Tile.RiverLink
{
neighbor = tileNeighbor2,
river = byShortHash2
};
potentialRivers.Add(item2);
List <Tile.RiverLink> potentialRivers2 = tiles[tileNeighbor2].potentialRivers;
item2 = new Tile.RiverLink
{
neighbor = num2,
river = byShortHash2
};
potentialRivers2.Add(item2);
}
}
}
