public UpdateSimViewSharedData(SimDebugView instance, byte[] texture_bytes, HashedString sim_view_mode, SimDebugView sim_debug_view)
{
this.instance = instance;
textureBytes = texture_bytes;
simViewMode = sim_view_mode;
simDebugView = sim_debug_view;
}
public static Color GetJoulesColour(SimDebugView instance, int cell)
{
float num = Grid.Element[cell].specificHeatCapacity * Grid.Temperature[cell] * (Grid.Mass[cell] * 1000f);
float t = 0.5f * num / (ElementLoader.FindElementByHash(SimHashes.SandStone).specificHeatCapacity * 294f * 1000000f);
return(Color.Lerp(Color.black, Color.red, t));
}
private static Color GetSimCheckErrorMapColour(SimDebugView instance, int cell)
{
Color result = Color.black;
Element element = Grid.Element[cell];
float num = Grid.Mass[cell];
float num2 = Grid.Temperature[cell];
if (float.IsNaN(num) || float.IsNaN(num2) || num > 10000f || num2 > 10000f)
{
return(Color.red);
}
if (element.IsVacuum)
{
result = ((num2 != 0f) ? Color.yellow : ((num == 0f) ? Color.gray : Color.blue));
}
else if (num2 < 10f)
{
result = Color.red;
}
else if (Grid.Mass[cell] < 1f && Grid.Pressure[cell] < 1f)
{
result = Color.green;
}
else if (num2 > element.highTemp + 3f && element.highTempTransition != null)
{
result = Color.magenta;
}
else if (num2 < element.lowTemp + 3f && element.lowTempTransition != null)
{
result = Color.cyan;
}
return(result);
}
private static Color GetGameGridColour(SimDebugView instance, int cell)
{
Color result = new Color32(0, 0, 0, byte.MaxValue);
switch (instance.gameGridMode)
{
case GameGridMode.DigAmount:
if (Grid.Element[cell].IsSolid)
{
float num = Grid.Damage[cell] / 255f;
result = Color.HSVToRGB(1f - num, 1f, 1f);
}
break;
case GameGridMode.GameSolidMap:
result = ((!Grid.Solid[cell]) ? Color.black : Color.white);
break;
case GameGridMode.Lighting:
result = ((Grid.LightCount[cell] <= 0 && LightGridManager.previewLux[cell] <= 0) ? Color.black : Color.white);
break;
case GameGridMode.DupePassable:
result = ((!Grid.DupePassable[cell]) ? Color.black : Color.white);
break;
}
return(result);
}
/// <summary>
/// Retrieves the overlay color for a particular cell when in the crop view.
/// </summary>
/// <param name="cell">The cell to check.</param>
/// <returns>The overlay color for this cell.</returns>
internal static Color GetColor(SimDebugView _, int cell)
{
var shade = Color.black;
var colors = GlobalAssets.Instance.colorSet;
var reason = Instance.cells[cell];
switch (reason)
{
case PipPlantFailedReasons.PlantCount:
shade = colors.cropGrowing;
break;
case PipPlantFailedReasons.NoPlantablePlot:
break;
case PipPlantFailedReasons.CanPlant:
shade = colors.cropGrown;
break;
case PipPlantFailedReasons.Pressure:
shade = colors.heatflowThreshold0;
break;
case PipPlantFailedReasons.Temperature:
default:
shade = colors.cropHalted;
break;
}
return(shade);
}
private static void SetDisease(SimDebugView instance, Texture texture)
{
Renderer component = instance.plane.GetComponent <Renderer>();
component.sharedMaterial = instance.diseaseMaterial;
component.sharedMaterial.mainTexture = instance.tex;
texture.filterMode = FilterMode.Bilinear;
}
private static void SetDefaultPoint(SimDebugView instance, Texture texture)
{
Renderer component = instance.plane.GetComponent <Renderer>();
component.sharedMaterial = instance.material;
component.sharedMaterial.mainTexture = instance.tex;
texture.filterMode = FilterMode.Point;
}
private static Color GetDangerColour(SimDebugView instance, int cell)
{
Color result = Color.black;
DangerAmount dangerAmount = DangerAmount.None;
if (!Grid.Element[cell].IsSolid)
{
float num = 0f;
if (Grid.Temperature[cell] < minMinionTemperature)
{
num = Mathf.Abs(Grid.Temperature[cell] - minMinionTemperature);
}
if (Grid.Temperature[cell] > maxMinionTemperature)
{
num = Mathf.Abs(Grid.Temperature[cell] - maxMinionTemperature);
}
if (num > 0f)
{
if (num < 10f)
{
dangerAmount = DangerAmount.VeryLow;
}
else if (num < 30f)
{
dangerAmount = DangerAmount.Low;
}
else if (num < 100f)
{
dangerAmount = DangerAmount.Moderate;
}
else if (num < 200f)
{
dangerAmount = DangerAmount.High;
}
else if (num < 400f)
{
dangerAmount = DangerAmount.VeryHigh;
}
else if (num > 800f)
{
dangerAmount = DangerAmount.Extreme;
}
}
}
if (dangerAmount < DangerAmount.VeryHigh && (Grid.Element[cell].IsVacuum || (Grid.Element[cell].IsGas && (Grid.Element[cell].id != SimHashes.Oxygen || Grid.Pressure[cell] < minMinionPressure))))
{
dangerAmount++;
}
if (dangerAmount != 0)
{
float num2 = (float)dangerAmount / 6f;
result = Color.HSVToRGB((80f - num2 * 80f) / 360f, 1f, 1f);
}
return(result);
}
private static Color GetDecorColour(SimDebugView instance, int cell)
{
Color result = Color.black;
if (!Grid.Solid[cell])
{
float decorAtCell = GameUtil.GetDecorAtCell(cell);
float num = decorAtCell / 100f;
result = ((!(num > 0f)) ? Color.Lerp(new Color(0.15f, 0f, 0f), new Color(1f, 0f, 0f), Mathf.Abs(num)) : Color.Lerp(new Color(0.15f, 0f, 0f), new Color(0f, 1f, 0f), Mathf.Abs(num)));
}
return(result);
}
private static Color GetPressureMapColour(SimDebugView instance, int cell)
{
Color32 c = Color.black;
if (Grid.Pressure[cell] > 0f)
{
float value = (Grid.Pressure[cell] - instance.minPressureExpected) / (instance.maxPressureExpected - instance.minPressureExpected);
float num = Mathf.Clamp(value, 0f, 1f);
float num2 = num * 0.9f;
c = new Color(num2, num2, num2, 1f);
}
return(c);
}
private static Color GetMassColour(SimDebugView instance, int cell)
{
Color result = Color.black;
if (!IsInsulated(cell))
{
float num = Grid.Mass[cell];
if (num > 0f)
{
float num2 = (num - Instance.minMassExpected) / (Instance.maxMassExpected - Instance.minMassExpected);
result = Color.HSVToRGB(1f - num2, 1f, 1f);
}
}
return(result);
}
private static Color GetThermalConductivityColour(SimDebugView instance, int cell)
{
bool flag = IsInsulated(cell);
Color result = Color.black;
float num = instance.maxThermalConductivity - instance.minThermalConductivity;
if (!flag && num != 0f)
{
float a = (Grid.Element[cell].thermalConductivity - instance.minThermalConductivity) / num;
a = Mathf.Max(a, 0f);
a = Mathf.Min(a, 1f);
result = new Color(a, a, a);
}
return(result);
}
private static Color GetSolidLiquidMapColour(SimDebugView instance, int cell)
{
Color result = Color.black;
switch (Grid.Element[cell].state & Element.State.Solid)
{
case Element.State.Solid:
result = Color.blue;
break;
case Element.State.Liquid:
result = Color.green;
break;
}
return(result);
}
private static Color GetDiseaseColour(SimDebugView instance, int cell)
{
Color result = Color.black;
if (Grid.DiseaseIdx[cell] != 255)
{
Disease disease = Db.Get().Diseases[Grid.DiseaseIdx[cell]];
result = disease.overlayColour;
result.a = SimUtil.DiseaseCountToAlpha(Grid.DiseaseCount[cell]);
}
else
{
result.a = 0f;
}
return(result);
}
public static Color GetRadiationColour(SimDebugView instance, int cell)
{
Color result = new Color(0.2f, 0.9f, 0.3f, Mathf.Clamp(Mathf.Sqrt((float)(Grid.RadiationCount[cell] + RadiationGridManager.previewLux[cell])) / Mathf.Sqrt(80000f), 0f, 1f));
if (Grid.RadiationCount[cell] > 71999)
{
float num = ((float)Grid.RadiationCount[cell] + (float)LightGridManager.previewLux[cell] - 71999f) / 8001f;
num /= 10f;
float r = result.r;
Vector3 vector = Grid.CellToPos2D(cell);
float xin = vector.x / 8f;
Vector3 vector2 = Grid.CellToPos2D(cell);
result.r = r + Mathf.Min(0.1f, PerlinSimplexNoise.noise(xin, vector2.y / 8f + (float)instance.currentFrame / 32f) * num);
}
return(result);
}
private static Color GetOxygenMapColour(SimDebugView instance, int cell)
{
Color result = Color.black;
if (!Grid.IsLiquid(cell) && !Grid.Solid[cell])
{
if (Grid.Mass[cell] > minimumBreathable && (Grid.Element[cell].id == SimHashes.Oxygen || Grid.Element[cell].id == SimHashes.ContaminatedOxygen))
{
float time = Mathf.Clamp((Grid.Mass[cell] - minimumBreathable) / optimallyBreathable, 0f, 1f);
result = instance.breathableGradient.Evaluate(time);
}
else
{
result = instance.unbreathableColour;
}
}
return(result);
}
private static Color GetStateChangeColour(SimDebugView instance, int cell)
{
Color result = Color.black;
Element element = Grid.Element[cell];
if (!element.IsVacuum)
{
float num = Grid.Temperature[cell];
float num2 = element.lowTemp * 0.05f;
float num3 = Mathf.Abs(num - element.lowTemp);
float a = num3 / num2;
float num4 = element.highTemp * 0.05f;
float num5 = Mathf.Abs(num - element.highTemp);
float b = num5 / num4;
float t = Mathf.Max(0f, 1f - Mathf.Min(a, b));
result = Color.Lerp(Color.black, Color.red, t);
}
return(result);
}
public static Color GetStateChangeProximityColour(SimDebugView instance, int cell)
{
float temperature = Grid.Temperature[cell];
Element element = Grid.Element[cell];
float lowTemp = element.lowTemp;
float highTemp = element.highTemp;
if (element.IsGas)
{
highTemp = Mathf.Min(lowTemp + 150f, highTemp);
return(GasTemperatureToColor(temperature, lowTemp, highTemp));
}
if (element.IsSolid)
{
lowTemp = Mathf.Max(highTemp - 150f, lowTemp);
return(SolidTemperatureToColor(temperature, lowTemp, highTemp));
}
return(TemperatureToColor(temperature, lowTemp, highTemp));
}
private static Color GetTileColour(SimDebugView instance, int cell)
{
float num = 0.33f;
Color result = new Color(num, num, num);
Element element = Grid.Element[cell];
bool flag = false;
foreach (Tag tileOverlayFilter in Game.Instance.tileOverlayFilters)
{
if (element.HasTag(tileOverlayFilter))
{
flag = true;
}
}
if (!flag)
{
return(result);
}
return(element.substance.uiColour);
}
public static Color GetNormalizedTemperatureColourMode(SimDebugView instance, int cell)
{
switch (Game.Instance.temperatureOverlayMode)
{
case Game.TemperatureOverlayModes.AbsoluteTemperature:
return(GetNormalizedTemperatureColour(instance, cell));
case Game.TemperatureOverlayModes.HeatFlow:
return(GetHeatFlowColour(instance, cell));
case Game.TemperatureOverlayModes.AdaptiveTemperature:
return(GetNormalizedTemperatureColour(instance, cell));
case Game.TemperatureOverlayModes.StateChange:
return(GetStateChangeProximityColour(instance, cell));
default:
return(GetNormalizedTemperatureColour(instance, cell));
}
}
public static Color GetRoomsColour(SimDebugView instance, int cell)
{
Color result = Color.black;
if (Grid.IsValidCell(instance.selectedCell))
{
CavityInfo cavityForCell = Game.Instance.roomProber.GetCavityForCell(cell);
if (cavityForCell != null && cavityForCell.room != null)
{
Room room = cavityForCell.room;
result = room.roomType.category.color;
result.a = 0.45f;
CavityInfo cavityForCell2 = Game.Instance.roomProber.GetCavityForCell(instance.selectedCell);
if (cavityForCell2 == cavityForCell)
{
result.a += 0.3f;
}
}
}
return(result);
}
public static Color GetNavColor(SimDebugView instance, int cell)
{
var ratio = NavigatorRecordManager.GetRatio(cell);
return(ratio > Threshold?Color.Lerp(Low, High, ratio) : None);
}
private static Color GetCellColor(SimDebugView instance, int cell)
{
return(cell == selectedCell ? new Color(0f, 1f, 0.3f, 0.3f) : Color.clear);
}
private static Color GetReservedColour(SimDebugView instance, int cell)
{
return((!Grid.Reserved[cell]) ? Color.black : Color.white);
}
public static Color GetNormalizedTemperatureColour(SimDebugView instance, int cell)
{
float temperature = Grid.Temperature[cell];
return(instance.NormalizedTemperature(temperature));
}
private static Color GetAllowPathFindingColour(SimDebugView instance, int cell)
{
return((!Grid.AllowPathfinding[cell]) ? Color.black : Color.white);
}
public static void DestroyInstance()
{
Instance = null;
}
private static Color GetBlack(SimDebugView instance, int cell)
{
return(Color.black);
}
private static Color GetHeatFlowColour(SimDebugView instance, int cell)
{
return(instance.NormalizedHeatFlow(cell));
}
protected override void OnPrefabInit()
{
Instance = this;
material = UnityEngine.Object.Instantiate(material);
diseaseMaterial = UnityEngine.Object.Instantiate(diseaseMaterial);
}
