// Token: 0x060034AF RID: 13487 RVA: 0x0015AB2C File Offset: 0x00158F2C
private static void onClickedTimeButton(SleekButton button)
{
int i;
for (i = 0; i < EditorEnvironmentLightingUI.timeButtons.Length; i++)
{
if (EditorEnvironmentLightingUI.timeButtons[i] == button)
{
break;
}
}
EditorEnvironmentLightingUI.selectedTime = (ELightingTime)i;
EditorEnvironmentLightingUI.updateSelection();
switch (EditorEnvironmentLightingUI.selectedTime)
{
case ELightingTime.DAWN:
LevelLighting.time = 0f;
break;
case ELightingTime.MIDDAY:
LevelLighting.time = LevelLighting.bias / 2f;
break;
case ELightingTime.DUSK:
LevelLighting.time = LevelLighting.bias;
break;
case ELightingTime.MIDNIGHT:
LevelLighting.time = 1f - (1f - LevelLighting.bias) / 2f;
break;
}
LevelLighting.updateClouds();
EditorEnvironmentLightingUI.timeSlider.state = LevelLighting.time;
}
public static void UpdateNightvision()
{
if ((Global.VisSettings.NightVision && Global.VisualsEnabled && !Global.AllOff) && !Hooks.askScreenshot.NeedingSpy)
{
if (LevelLighting.vision != ELightingVision.MILITARY)
{
LevelLighting.vision = ELightingVision.MILITARY;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
Global.LastUsedNight = true;
}
}
else
{
if (Global.LastUsedNight)
{
LevelLighting.vision = ELightingVision.NONE;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
Global.LastUsedNight = false;
}
}
}
public static float getWaterSurfaceElevation(Vector3 point)
{
bool flag = false;
float num = -1024f;
foreach (WaterVolume waterVolume in WaterSystem.volumes)
{
if (WaterUtility.isPointInsideVolume(waterVolume, point))
{
return(WaterUtility.getWaterSurfaceElevation(waterVolume, point));
}
Ray ray;
ray..ctor(point, new Vector3(0f, -1f, 0f));
RaycastHit raycastHit;
if (waterVolume.box.Raycast(ray, ref raycastHit, 2048f) && raycastHit.point.y > num)
{
num = raycastHit.point.y;
flag = true;
}
}
if (flag)
{
return(num);
}
if (Level.info != null && Level.info.configData.Use_Legacy_Water)
{
return(LevelLighting.getWaterSurfaceElevation());
}
return(-1024f);
}
private void Update()
{
byte b;
byte b2;
if (Regions.tryGetCoordinate(base.transform.position, out b, out b2) && (b != this.region_x || b2 != this.region_y))
{
byte region_x = this.region_x;
byte region_y = this.region_y;
this._region_x = b;
this._region_y = b2;
if (this.onRegionUpdated != null)
{
this.onRegionUpdated(region_x, region_y, b, b2);
}
}
byte b3;
LevelNavigation.tryGetBounds(base.transform.position, out b3);
if (b3 != this.bound)
{
byte bound = this.bound;
this._bound = b3;
if (this.onBoundUpdated != null)
{
this.onBoundUpdated(bound, b3);
}
}
this.effectNode = null;
for (int i = 0; i < LevelNodes.nodes.Count; i++)
{
Node node = LevelNodes.nodes[i];
if (node.type == ENodeType.EFFECT)
{
EffectNode effectNode = (EffectNode)node;
if (effectNode.shape == ENodeShape.SPHERE)
{
if ((base.transform.position - effectNode.point).sqrMagnitude < effectNode.editorRadius)
{
this.effectNode = effectNode;
break;
}
}
else if (effectNode.shape == ENodeShape.BOX && Mathf.Abs(base.transform.position.x - effectNode.point.x) < effectNode.bounds.x && Mathf.Abs(base.transform.position.y - effectNode.point.y) < effectNode.bounds.y && Mathf.Abs(base.transform.position.z - effectNode.point.z) < effectNode.bounds.z)
{
this.effectNode = effectNode;
break;
}
}
}
AmbianceVolume effectNode2;
if (this.effectNode == null && AmbianceUtility.isPointInsideVolume(base.transform.position, out effectNode2))
{
this.effectNode = effectNode2;
}
LevelLighting.updateLocal(MainCamera.instance.transform.position, 0f, this.effectNode);
}
public static bool isPointUnderwater(Vector3 point, out WaterVolume volume)
{
if (Level.info != null && Level.info.configData.Use_Legacy_Water && LevelLighting.isPositionUnderwater(point))
{
volume = null;
return(true);
}
return(WaterUtility.isPointInsideVolume(point, out volume));
}
private void Start()
{
this._region_x = byte.MaxValue;
this._region_y = byte.MaxValue;
this._bound = byte.MaxValue;
EditorArea.instance = this;
LevelLighting.updateLighting();
this.triggerRegistered();
}
void MiscPage()
{
GUI.Label(new Rect(415, 91, 100, 30), "<size=20>Misc:</size>");
if (GUI.Button(new Rect(240, 153, 140, 30), "<size=13>No Rain</size>"))
{
LevelLighting.rainyness = ELightingRain.NONE;
}
if (GUI.Button(new Rect(240, 186, 140, 30), "<size=13>No Fog</size>"))
{
RenderSettings.fog = (!RenderSettings.fog);
}
if (GUI.Button(new Rect(240, 219, 140, 30), "<size=13>No Water</size>"))
{
if (Altitude == 0f)
{
Altitude = LevelLighting.seaLevel;
}
LevelLighting.seaLevel = LevelLighting.seaLevel == 0f ? Altitude : 0f;
}
GUI.Label(new Rect(383, 120, 140, 35), $"<size=14>Night Vision: {Nv}</size>");
if (GUI.Button(new Rect(383, 153, 140, 30), "<size=13>Military</size>"))
{
Nv = NvType.Military;
LevelLighting.vision = ELightingVision.MILITARY;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
}
if (GUI.Button(new Rect(383, 186, 140, 30), "<size=13>Civilian</size>"))
{
Nv = NvType.Civilian;
LevelLighting.vision = ELightingVision.CIVILIAN;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
}
if (GUI.Button(new Rect(383, 219, 140, 30), "<size=13>None</size>"))
{
Nv = NvType.None;
LevelLighting.vision = ELightingVision.NONE;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
}
}
// Token: 0x060034B2 RID: 13490 RVA: 0x0015AC34 File Offset: 0x00159034
private static void onPickedColorPicker(SleekColorPicker picker, Color state)
{
int i;
for (i = 0; i < EditorEnvironmentLightingUI.colorPickers.Length; i++)
{
if (EditorEnvironmentLightingUI.colorPickers[i] == picker)
{
break;
}
}
LevelLighting.times[(int)EditorEnvironmentLightingUI.selectedTime].colors[i] = state;
LevelLighting.updateLighting();
}
protected virtual void createWaterPlanes()
{
if (!Dedicator.isDedicated && this.waterPlane == null)
{
this.waterPlane = Object.Instantiate <GameObject>(Resources.Load <GameObject>("Level/Water_Plane"));
this.waterPlane.name = "Plane";
this.waterPlane.transform.parent = base.transform;
this.waterPlane.transform.localPosition = new Vector3(0f, 0.5f, 0f);
this.waterPlane.transform.localRotation = Quaternion.identity;
this.waterPlane.transform.localScale = new Vector3(1f, 1f, 1f);
this.waterPlane.SetActive(this.isSurfaceVisible);
this.planarReflection = this.waterPlane.GetComponent <PlanarReflection>();
int num = Mathf.Max(1, Mathf.FloorToInt(base.transform.localScale.x / (float)WaterVolume.WATER_SURFACE_TILE_SIZE));
int num2 = Mathf.Max(1, Mathf.FloorToInt(base.transform.localScale.z / (float)WaterVolume.WATER_SURFACE_TILE_SIZE));
float num3 = 1f / (float)num;
float num4 = 1f / (float)num2;
for (int i = 0; i < num; i++)
{
for (int j = 0; j < num2; j++)
{
GameObject gameObject = Object.Instantiate <GameObject>(Resources.Load <GameObject>("Level/Water_Tile"));
gameObject.name = string.Concat(new object[]
{
"Tile_",
i,
"_",
j
});
gameObject.transform.parent = this.waterPlane.transform;
gameObject.transform.localPosition = new Vector3(-0.5f + num3 / 2f + (float)i * num3, 0f, -0.5f + num4 / 2f + (float)j * num4);
gameObject.transform.localRotation = Quaternion.identity;
gameObject.transform.localScale = new Vector3(0.01f * num3, 0.01f, 0.01f * num4);
if (this.sea == null)
{
this.sea = gameObject.GetComponent <Renderer>().material;
}
else
{
gameObject.GetComponent <Renderer>().material = this.sea;
}
gameObject.GetComponent <WaterTile>().reflection = this.planarReflection;
}
}
this.planarReflection.sharedMaterial = this.sea;
this.applyGraphicsSettings();
LevelLighting.updateLighting();
}
}
// Token: 0x060034B3 RID: 13491 RVA: 0x0015AC8C File Offset: 0x0015908C
private static void onDraggedSingleSlider(SleekSlider slider, float state)
{
int i;
for (i = 0; i < EditorEnvironmentLightingUI.singleSliders.Length; i++)
{
if (EditorEnvironmentLightingUI.singleSliders[i] == slider)
{
break;
}
}
LevelLighting.times[(int)EditorEnvironmentLightingUI.selectedTime].singles[i] = state;
LevelLighting.updateLighting();
if (i == 2)
{
LevelLighting.updateClouds();
}
}
public void Update()
{
if (Injections.Overrides.PL.tmp_screen)
{
Information.beingScreened = true;
if (dManager.highlights.Count > 0)
{
foreach (HighlightType g in dManager.highlights)
{
if (g.h != null)
{
GameObject.Destroy(g.h);
}
dManager.highlights.Remove(g);
}
}
LevelLighting.vision = ELightingVision.NONE;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
ComponentManager.hack_Weapons.hideSpread();
Player.player.StartCoroutine("takeScreenshot");
lastScreenshot = DateTime.Now;
Injections.Overrides.PL.tmp_screen = false;
}
if (Information.beingScreened && !Injections.Overrides.PL.tmp_screen && ((DateTime.Now - lastScreenshot).TotalMilliseconds > 3000))
{
Information.beingScreened = false;
string say = "";
if (Injections.Overrides.PL.tmp_calls > 5)
{
say = "Someone has used Observetory on you!";
}
else
{
say = "Someone has used Spy on you!";
}
ChatManager.list(Provider.client, EChatMode.SAY, Color.magenta, say);
Injections.Overrides.PL.tmp_calls = 0;
}
}
public static void save()
{
LevelObjects.save();
LevelLighting.save();
LevelGround.save();
LevelRoads.save();
if (!Level.isVR)
{
LevelNavigation.save();
LevelNodes.save();
LevelItems.save();
LevelPlayers.save();
LevelZombies.save();
LevelVehicles.save();
LevelAnimals.save();
LevelVisibility.save();
}
Editor.save();
}
public static void getUnderwaterInfo(Vector3 point, out bool isUnderwater, out float surfaceElevation)
{
if (Level.info != null && Level.info.configData.Use_Legacy_Water)
{
isUnderwater = LevelLighting.isPositionUnderwater(point);
surfaceElevation = LevelLighting.getWaterSurfaceElevation();
}
else
{
isUnderwater = false;
surfaceElevation = -1024f;
}
WaterVolume volume;
if (!isUnderwater && WaterUtility.isPointInsideVolume(point, out volume))
{
isUnderwater = true;
surfaceElevation = WaterUtility.getWaterSurfaceElevation(volume, point);
}
}
// Token: 0x0600016F RID: 367 RVA: 0x0000F9D4 File Offset: 0x0000DBD4
public void Update()
{
OptimizationVariables.MainCam = Camera.main;
if (!DrawUtilities.ShouldRun())
{
return;
}
if (!MenuComponent.IsInMenu && !MiscOptions.PanicMode)
{
foreach (KeyValuePair <string, Hotkey> keyValuePair in HotkeyOptions.ChatKeys)
{
KeyCode[] keys = keyValuePair.Value.Keys;
if (keys.Any(new Func <KeyCode, bool>(Input.GetKeyDown)) && keys.All(new Func <KeyCode, bool>(Input.GetKey)))
{
ChatManager.sendChat(EChatMode.GLOBAL, keyValuePair.Key);
}
}
}
if (MiscComponent.fall != MiscOptions.SlowFall)
{
MiscComponent.fall = MiscOptions.SlowFall;
Player.player.movement.pluginGravityMultiplier = (MiscComponent.fall ? 0f : 1f);
}
if (!MiscOptions.NightVision)
{
if (MiscOptions.WasNightVision)
{
LevelLighting.vision = ELightingVision.NONE;
LevelLighting.updateLighting();
PlayerLifeUI.updateGrayscale();
MiscOptions.WasNightVision = false;
}
return;
}
LevelLighting.vision = ELightingVision.MILITARY;
LevelLighting.updateLighting();
PlayerLifeUI.updateGrayscale();
MiscOptions.WasNightVision = true;
}
public void OnGUI()
{
if (isOn && ctrl_Connector.isOn)
{
window_Main = GUILayout.Window(ctrl_Connector.id_Player, window_Main, onWindow, "Player Hack Menu");
}
if (Event.current.type == EventType.Repaint)
{
if (nightvision_military)
{
LevelLighting.vision = ELightingVision.MILITARY;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
prev_night = true;
}
else if (nightvision_civilian)
{
LevelLighting.vision = ELightingVision.CIVILIAN;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
prev_night = true;
}
else
{
if (prev_night)
{
LevelLighting.vision = ELightingVision.NONE;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
prev_night = false;
}
}
}
}
public void OnGUI()
{
if (Information.beingScreened)
{
return;
}
if (Event.current.type == EventType.Repaint)
{
if (nightvision_military)
{
LevelLighting.vision = ELightingVision.MILITARY;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
prev_night = true;
}
else if (nightvision_civilian)
{
LevelLighting.vision = ELightingVision.CIVILIAN;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
prev_night = true;
}
else
{
if (prev_night)
{
LevelLighting.vision = ELightingVision.NONE;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
prev_night = false;
}
}
}
}
// Token: 0x0600342A RID: 13354 RVA: 0x00154300 File Offset: 0x00152700
public static Texture2D captureIcon(ushort id, ushort skin, Transform model, Transform icon, int width, int height, float orthoSize)
{
ItemTool.tool.transform.position = icon.position;
ItemTool.tool.transform.rotation = icon.rotation;
RenderTexture temporary = RenderTexture.GetTemporary(width, height, 16, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
temporary.name = string.Concat(new object[]
{
"Render_",
id,
"_",
skin
});
RenderTexture.active = temporary;
ItemTool.tool.GetComponent <Camera>().targetTexture = temporary;
ItemTool.tool.GetComponent <Camera>().orthographicSize = orthoSize;
bool fog = RenderSettings.fog;
AmbientMode ambientMode = RenderSettings.ambientMode;
Color ambientSkyColor = RenderSettings.ambientSkyColor;
Color ambientEquatorColor = RenderSettings.ambientEquatorColor;
Color ambientGroundColor = RenderSettings.ambientGroundColor;
RenderSettings.fog = false;
RenderSettings.ambientMode = AmbientMode.Trilight;
RenderSettings.ambientSkyColor = Color.white;
RenderSettings.ambientEquatorColor = Color.white;
RenderSettings.ambientGroundColor = Color.white;
if (Provider.isConnected)
{
LevelLighting.setEnabled(false);
}
ItemTool.tool.GetComponent <Light>().enabled = true;
ItemTool.tool.GetComponent <Camera>().cullingMask = (RayMasks.ITEM | RayMasks.VEHICLE | RayMasks.MEDIUM | RayMasks.SMALL);
ItemTool.tool.GetComponent <Camera>().farClipPlane = 16f;
ItemTool.tool.GetComponent <Camera>().Render();
ItemTool.tool.GetComponent <Light>().enabled = false;
if (Provider.isConnected)
{
LevelLighting.setEnabled(true);
}
RenderSettings.fog = fog;
RenderSettings.ambientMode = ambientMode;
RenderSettings.ambientSkyColor = ambientSkyColor;
RenderSettings.ambientEquatorColor = ambientEquatorColor;
RenderSettings.ambientGroundColor = ambientGroundColor;
model.position = new Vector3(0f, -256f, -256f);
UnityEngine.Object.Destroy(model.gameObject);
Texture2D texture2D = new Texture2D(width, height, TextureFormat.ARGB32, false, true);
texture2D.name = string.Concat(new object[]
{
"Icon_",
id,
"_",
skin
});
texture2D.filterMode = FilterMode.Point;
texture2D.ReadPixels(new Rect(0f, 0f, (float)width, (float)height), 0, 0);
texture2D.Apply();
RenderTexture.ReleaseTemporary(temporary);
return(texture2D);
}
// Token: 0x060028BE RID: 10430 RVA: 0x000F75F4 File Offset: 0x000F59F4
private void Update()
{
if (!Level.isLoaded || Level.info == null)
{
return;
}
if (Level.isEditor)
{
LevelLighting.updateLighting();
}
else if (Level.info.type == ELevelType.SURVIVAL)
{
this.updateLighting();
}
if (Provider.isServer)
{
if (LevelLighting.canRain)
{
if (!LightingManager.hasRain)
{
LightingManager.rainFrequency = (uint)(UnityEngine.Random.Range(Provider.modeConfigData.Events.Rain_Frequency_Min, Provider.modeConfigData.Events.Rain_Frequency_Max) * LightingManager.cycle * LevelLighting.rainFreq);
LightingManager.rainDuration = (uint)(UnityEngine.Random.Range(Provider.modeConfigData.Events.Rain_Duration_Min, Provider.modeConfigData.Events.Rain_Duration_Max) * LightingManager.cycle * LevelLighting.rainDur);
LightingManager._hasRain = true;
LightingManager.lastRain = Time.realtimeSinceStartup;
}
switch (LevelLighting.rainyness)
{
case ELightingRain.NONE:
if (LightingManager.rainFrequency > 0u)
{
if (Time.realtimeSinceStartup - LightingManager.lastRain > 1f)
{
LightingManager.rainFrequency -= 1u;
LightingManager.lastRain = Time.realtimeSinceStartup;
}
}
else
{
LightingManager.manager.channel.send("tellLightingRain", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
1
});
LightingManager.lastRain = Time.realtimeSinceStartup;
}
break;
case ELightingRain.PRE_DRIZZLE:
if (Time.realtimeSinceStartup - LightingManager.lastRain > 20f)
{
LightingManager.manager.channel.send("tellLightingRain", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
2
});
LightingManager.lastRain = Time.realtimeSinceStartup;
}
break;
case ELightingRain.DRIZZLE:
if (LightingManager.rainDuration > 0u)
{
if (Time.realtimeSinceStartup - LightingManager.lastRain > 1f)
{
LightingManager.rainDuration -= 1u;
LightingManager.lastRain = Time.realtimeSinceStartup;
}
}
else
{
LightingManager.manager.channel.send("tellLightingRain", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
3
});
LightingManager.lastRain = Time.realtimeSinceStartup;
}
break;
case ELightingRain.POST_DRIZZLE:
if (Time.realtimeSinceStartup - LightingManager.lastRain > 20f)
{
LightingManager.manager.channel.send("tellLightingRain", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
0
});
LightingManager._hasRain = false;
}
break;
}
}
if (LevelLighting.canSnow)
{
if (!LightingManager.hasSnow)
{
LightingManager.snowFrequency = (uint)(UnityEngine.Random.Range(Provider.modeConfigData.Events.Snow_Frequency_Min, Provider.modeConfigData.Events.Snow_Frequency_Max) * LightingManager.cycle * LevelLighting.snowFreq);
LightingManager.snowDuration = (uint)(UnityEngine.Random.Range(Provider.modeConfigData.Events.Snow_Duration_Min, Provider.modeConfigData.Events.Snow_Duration_Max) * LightingManager.cycle * LevelLighting.snowDur);
LightingManager._hasSnow = true;
LightingManager.lastSnow = Time.realtimeSinceStartup;
}
switch (LevelLighting.snowyness)
{
case ELightingSnow.NONE:
if (LightingManager.snowFrequency > 0u)
{
if (Time.realtimeSinceStartup - LightingManager.lastSnow > 1f)
{
LightingManager.snowFrequency -= 1u;
LightingManager.lastSnow = Time.realtimeSinceStartup;
}
}
else
{
LightingManager.manager.channel.send("tellLightingSnow", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
1
});
LightingManager.lastSnow = Time.realtimeSinceStartup;
}
break;
case ELightingSnow.PRE_BLIZZARD:
if (Time.realtimeSinceStartup - LightingManager.lastSnow > 20f)
{
LightingManager.manager.channel.send("tellLightingSnow", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
2
});
LightingManager.lastSnow = Time.realtimeSinceStartup;
}
break;
case ELightingSnow.BLIZZARD:
if (LightingManager.snowDuration > 0u)
{
if (Time.realtimeSinceStartup - LightingManager.lastSnow > 1f)
{
LightingManager.snowDuration -= 1u;
LightingManager.lastSnow = Time.realtimeSinceStartup;
}
}
else
{
LightingManager.manager.channel.send("tellLightingSnow", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
3
});
LightingManager.lastSnow = Time.realtimeSinceStartup;
}
break;
case ELightingSnow.POST_BLIZZARD:
if (Time.realtimeSinceStartup - LightingManager.lastSnow > 20f)
{
LightingManager.manager.channel.send("tellLightingSnow", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
0
});
LightingManager._hasSnow = false;
}
break;
}
}
}
}
// Token: 0x060002CA RID: 714 RVA: 0x0001C370 File Offset: 0x0001A570
public void Update()
{
bool hang = MiscOptions.hang;
if (hang)
{
Player.player.movement.pluginGravityMultiplier = 0f;
}
else
{
Player.player.movement.pluginGravityMultiplier = 1f;
}
bool flag = Camera.main != null && OptimizationVariables.MainCam == null;
bool flag2 = flag;
if (flag2)
{
OptimizationVariables.MainCam = Camera.main;
}
bool flag3 = !OptimizationVariables.MainPlayer;
bool flag4 = !flag3;
if (flag4)
{
bool flag5 = !DrawUtilities.ShouldRun();
bool flag6 = !flag5;
if (flag6)
{
int num;
Provider.provider.statisticsService.userStatisticsService.getStatistic("Kills_Players", out num);
bool oofOnDeath = WeaponOptions.OofOnDeath;
bool flag7 = oofOnDeath;
if (flag7)
{
bool flag8 = num != this.currentKills;
bool flag9 = flag8;
if (flag9)
{
bool flag10 = this.currentKills != -1;
bool flag11 = flag10;
if (flag11)
{
OptimizationVariables.MainPlayer.GetComponentInChildren <AudioSource>().PlayOneShot(AssetVariables.Audio["oof"], 3f);
}
this.currentKills = num;
}
}
else
{
this.currentKills = num;
}
bool nightVision = MiscOptions.NightVision;
bool flag12 = nightVision;
if (flag12)
{
LevelLighting.vision = ELightingVision.MILITARY;
LevelLighting.updateLighting();
PlayerLifeUI.updateGrayscale();
MiscOptions.WasNightVision = true;
}
else
{
bool wasNightVision = MiscOptions.WasNightVision;
bool flag13 = wasNightVision;
if (flag13)
{
LevelLighting.vision = ELightingVision.NONE;
LevelLighting.updateLighting();
PlayerLifeUI.updateGrayscale();
MiscOptions.WasNightVision = false;
}
}
bool enableDistanceCrash = MiscOptions.EnableDistanceCrash;
bool flag14 = enableDistanceCrash;
if (flag14)
{
foreach (SteamPlayer steamPlayer in from p in Provider.clients
where p.player != OptimizationVariables.MainPlayer && VectorUtilities.GetDistance(p.player.transform.position, OptimizationVariables.MainPlayer.transform.position) < (double)MiscOptions.CrashDistance
select p)
{
bool flag15 = !PlayerCrashThread.CrashTargets.Contains(steamPlayer.playerID.steamID);
bool flag16 = flag15;
if (flag16)
{
PlayerCrashThread.CrashTargets.Add(steamPlayer.playerID.steamID);
}
}
}
bool isDead = OptimizationVariables.MainPlayer.life.isDead;
bool flag17 = isDead;
if (flag17)
{
MiscComponent.LastDeath = OptimizationVariables.MainPlayer.transform.position;
}
bool crashByName = MiscOptions.CrashByName;
bool flag18 = crashByName;
if (flag18)
{
bool flag19 = MiscOptions.CrashWords.ToArray().Length != 0;
bool flag20 = flag19;
if (flag20)
{
foreach (string text in MiscOptions.CrashWords)
{
foreach (SteamPlayer steamPlayer2 in Provider.clients)
{
bool flag21 = FriendUtilities.IsFriendly(steamPlayer2.player);
bool flag22 = !flag21;
if (flag22)
{
bool flag23 = !steamPlayer2.playerID.characterName.ToLower().Contains(text.ToLower());
bool flag24 = !flag23;
if (flag24)
{
PlayerCrashThread.CrashTargets.Add(steamPlayer2.playerID.steamID);
break;
}
}
}
}
}
bool flag25 = MiscOptions.CrashIDs.ToArray().Length != 0;
bool flag26 = flag25;
if (flag26)
{
foreach (string b in MiscOptions.CrashIDs)
{
foreach (SteamPlayer steamPlayer3 in Provider.clients)
{
bool flag27 = FriendUtilities.IsFriendly(steamPlayer3.player);
bool flag28 = !flag27;
if (flag28)
{
bool flag29 = steamPlayer3.playerID.steamID.ToString() != b;
bool flag30 = !flag29;
if (flag30)
{
PlayerCrashThread.CrashTargets.Add(steamPlayer3.playerID.steamID);
break;
}
}
}
}
}
bool noFlash = MiscOptions.NoFlash;
if (noFlash)
{
bool flag31 = MiscOptions.NoFlash && ((Color)typeof(PlayerUI).GetField("stunColor", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null)).a > 0f;
if (flag31)
{
Color color = (Color)typeof(PlayerUI).GetField("stunColor", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
color.a = 0f;
typeof(PlayerUI).GetField("stunColor", BindingFlags.Static | BindingFlags.NonPublic).SetValue(null, color);
}
}
}
}
}
}
public static Texture2D getCard(Transform item, Transform hook_0, Transform hook_1, int width, int height, float size, float range)
{
if (item == null)
{
return(null);
}
item.position = new Vector3(-256f, -256f, 0f);
RenderTexture temporary = RenderTexture.GetTemporary(width, height, 16, 0, 2);
temporary.name = "Card_Render";
RenderTexture.active = temporary;
ItemTool.tool.GetComponent <Camera>().targetTexture = temporary;
ItemTool.tool.GetComponent <Camera>().orthographicSize = size;
Texture2D texture2D = new Texture2D(width * 2, height, 5, false, false);
texture2D.name = "Card_Atlas";
texture2D.filterMode = 0;
texture2D.wrapMode = 1;
bool fog = RenderSettings.fog;
AmbientMode ambientMode = RenderSettings.ambientMode;
Color ambientSkyColor = RenderSettings.ambientSkyColor;
Color ambientEquatorColor = RenderSettings.ambientEquatorColor;
Color ambientGroundColor = RenderSettings.ambientGroundColor;
RenderSettings.fog = false;
RenderSettings.ambientMode = 1;
RenderSettings.ambientSkyColor = Color.white;
RenderSettings.ambientEquatorColor = Color.white;
RenderSettings.ambientGroundColor = Color.white;
if (Provider.isConnected)
{
LevelLighting.setEnabled(false);
}
ItemTool.tool.GetComponent <Camera>().cullingMask = RayMasks.RESOURCE;
ItemTool.tool.GetComponent <Camera>().farClipPlane = range;
ItemTool.tool.transform.position = hook_0.position;
ItemTool.tool.transform.rotation = hook_0.rotation;
ItemTool.tool.GetComponent <Camera>().Render();
texture2D.ReadPixels(new Rect(0f, 0f, (float)width, (float)height), 0, 0);
ItemTool.tool.transform.position = hook_1.position;
ItemTool.tool.transform.rotation = hook_1.rotation;
ItemTool.tool.GetComponent <Camera>().Render();
texture2D.ReadPixels(new Rect(0f, 0f, (float)width, (float)height), width, 0);
if (Provider.isConnected)
{
LevelLighting.setEnabled(true);
}
RenderSettings.fog = fog;
RenderSettings.ambientMode = ambientMode;
RenderSettings.ambientSkyColor = ambientSkyColor;
RenderSettings.ambientEquatorColor = ambientEquatorColor;
RenderSettings.ambientGroundColor = ambientGroundColor;
item.position = new Vector3(0f, -256f, -256f);
Object.Destroy(item.gameObject);
for (int i = 0; i < texture2D.width; i++)
{
for (int j = 0; j < texture2D.height; j++)
{
Color32 color = texture2D.GetPixel(i, j);
if (color.r == 255 && color.g == 255 && color.b == 255)
{
color.a = 0;
}
else
{
color.a = byte.MaxValue;
}
texture2D.SetPixel(i, j, color);
}
}
texture2D.Apply();
RenderTexture.ReleaseTemporary(temporary);
return(texture2D);
}
private void Update()
{
if (ItemTool.icons == null || ItemTool.icons.Count == 0)
{
return;
}
ItemIconInfo itemIconInfo = ItemTool.icons.Dequeue();
if (itemIconInfo == null)
{
return;
}
if (itemIconInfo.itemAsset == null)
{
return;
}
Transform item = ItemTool.getItem(itemIconInfo.id, itemIconInfo.skin, itemIconInfo.quality, itemIconInfo.state, false, itemIconInfo.itemAsset, itemIconInfo.skinAsset);
item.position = new Vector3(-256f, -256f, 0f);
Transform transform;
if (itemIconInfo.scale && itemIconInfo.skin != 0)
{
if (itemIconInfo.itemAsset.size2_z == 0f)
{
item.position = new Vector3(0f, -256f, -256f);
Object.Destroy(item.gameObject);
Assets.errors.Add("Failed to create a skin icon of size 0 for " + itemIconInfo.id + ".");
return;
}
transform = item.FindChild("Icon2");
if (transform == null)
{
item.position = new Vector3(0f, -256f, -256f);
Object.Destroy(item.gameObject);
Assets.errors.Add("Failed to find a skin icon hook on " + itemIconInfo.id + ".");
return;
}
}
else
{
if (itemIconInfo.itemAsset.size_z == 0f)
{
item.position = new Vector3(0f, -256f, -256f);
Object.Destroy(item.gameObject);
Assets.errors.Add("Failed to create an item icon of size 0 for " + itemIconInfo.id + ".");
return;
}
transform = item.FindChild("Icon");
if (transform == null)
{
item.position = new Vector3(0f, -256f, -256f);
Object.Destroy(item.gameObject);
Assets.errors.Add("Failed to find an item icon hook on " + itemIconInfo.id + ".");
return;
}
}
ItemTool.tool.transform.position = transform.position;
ItemTool.tool.transform.rotation = transform.rotation;
RenderTexture temporary = RenderTexture.GetTemporary(itemIconInfo.x, itemIconInfo.y, 16, 0, 2);
temporary.name = string.Concat(new object[]
{
"Item_Render_",
itemIconInfo.id,
"_",
itemIconInfo.skin
});
RenderTexture.active = temporary;
ItemTool.tool.GetComponent <Camera>().targetTexture = temporary;
ItemTool.tool.GetComponent <Camera>().orthographicSize = itemIconInfo.itemAsset.size_z;
if (itemIconInfo.scale)
{
if (itemIconInfo.skin != 0)
{
ItemTool.tool.GetComponent <Camera>().orthographicSize = itemIconInfo.itemAsset.size2_z;
}
else
{
float num = (float)itemIconInfo.itemAsset.size_x / (float)itemIconInfo.itemAsset.size_y;
ItemTool.tool.GetComponent <Camera>().orthographicSize *= num;
}
}
bool fog = RenderSettings.fog;
AmbientMode ambientMode = RenderSettings.ambientMode;
Color ambientSkyColor = RenderSettings.ambientSkyColor;
Color ambientEquatorColor = RenderSettings.ambientEquatorColor;
Color ambientGroundColor = RenderSettings.ambientGroundColor;
RenderSettings.fog = false;
RenderSettings.ambientMode = 1;
RenderSettings.ambientSkyColor = Color.white;
RenderSettings.ambientEquatorColor = Color.white;
RenderSettings.ambientGroundColor = Color.white;
if (Provider.isConnected)
{
LevelLighting.setEnabled(false);
}
ItemTool.tool.GetComponent <Light>().enabled = true;
ItemTool.tool.GetComponent <Camera>().cullingMask = RayMasks.ITEM;
ItemTool.tool.GetComponent <Camera>().farClipPlane = 16f;
ItemTool.tool.GetComponent <Camera>().Render();
ItemTool.tool.GetComponent <Light>().enabled = false;
if (Provider.isConnected)
{
LevelLighting.setEnabled(true);
}
RenderSettings.fog = fog;
RenderSettings.ambientMode = ambientMode;
RenderSettings.ambientSkyColor = ambientSkyColor;
RenderSettings.ambientEquatorColor = ambientEquatorColor;
RenderSettings.ambientGroundColor = ambientGroundColor;
item.position = new Vector3(0f, -256f, -256f);
Object.Destroy(item.gameObject);
Texture2D texture2D = new Texture2D(itemIconInfo.x, itemIconInfo.y, 5, false, true);
texture2D.name = string.Concat(new object[]
{
"Item_Icon_",
itemIconInfo.id,
"_",
itemIconInfo.skin
});
texture2D.filterMode = 0;
texture2D.ReadPixels(new Rect(0f, 0f, (float)itemIconInfo.x, (float)itemIconInfo.y), 0, 0);
texture2D.Apply();
RenderTexture.ReleaseTemporary(temporary);
if (itemIconInfo.callback != null)
{
itemIconInfo.callback(texture2D);
}
if (itemIconInfo.state.Length == 0 && itemIconInfo.skin == 0 && itemIconInfo.x == (int)(itemIconInfo.itemAsset.size_x * 50) && itemIconInfo.y == (int)(itemIconInfo.itemAsset.size_y * 50) && !ItemTool.cache.ContainsKey(itemIconInfo.id))
{
ItemTool.cache.Add(itemIconInfo.id, texture2D);
}
}
public IEnumerator init(int id)
{
if (!Level.isVR)
{
LevelNavigation.load();
}
LoadingUI.updateProgress(1f / Level.STEPS);
yield return null;
LevelObjects.load();
LoadingUI.updateProgress(2f / Level.STEPS);
yield return null;
LevelLighting.load(Level.size);
LoadingUI.updateProgress(3f / Level.STEPS);
yield return null;
LevelGround.load(Level.size);
LoadingUI.updateProgress(4f / Level.STEPS);
yield return null;
LevelRoads.load();
LoadingUI.updateProgress(5f / Level.STEPS);
yield return null;
if (!Level.isVR)
{
LevelNodes.load();
LoadingUI.updateProgress(6f / Level.STEPS);
yield return null;
LevelItems.load();
LoadingUI.updateProgress(7f / Level.STEPS);
yield return null;
}
LevelPlayers.load();
LoadingUI.updateProgress(8f / Level.STEPS);
yield return null;
if (!Level.isVR)
{
LevelZombies.load();
LoadingUI.updateProgress(9f / Level.STEPS);
yield return null;
LevelVehicles.load();
LoadingUI.updateProgress(10f / Level.STEPS);
yield return null;
LevelAnimals.load();
LoadingUI.updateProgress(11f / Level.STEPS);
yield return null;
}
LevelVisibility.load();
LoadingUI.updateProgress(12f / Level.STEPS);
yield return null;
if (Level.loadingSteps != null)
{
Level.loadingSteps();
}
yield return null;
LevelBarricades.load();
yield return null;
LevelStructures.load();
Level._hash = Hash.combine(new byte[][]
{
Level.getLevelHash(Level.info.path),
LevelGround.hash,
LevelLighting.hash,
LevelObjects.hash
});
Physics.gravity = new Vector3(0f, Level.info.configData.Gravity, 0f);
yield return null;
Resources.UnloadUnusedAssets();
GC.Collect();
yield return null;
Level._editing = new GameObject().transform;
Level.editing.name = "Editing";
Level.editing.parent = Level.level;
if (Level.isEditor)
{
Level.mapper = ((GameObject)Object.Instantiate(Resources.Load("Edit/Mapper"))).transform;
Level.mapper.name = "Mapper";
Level.mapper.parent = Level.editing;
Level.mapper.position = new Vector3(0f, 1028f, 0f);
Level.mapper.rotation = Quaternion.Euler(90f, 0f, 0f);
Level.mapper.GetComponent<Camera>().orthographicSize = (float)(Level.size / 2 - Level.border);
if (Level.isDevkit)
{
GameObject gameObject = Object.Instantiate<GameObject>(Resources.Load<GameObject>("Edit2/Editor"));
if (gameObject != null)
{
gameObject.name = "Editor";
gameObject.transform.parent = Level.editing;
}
}
else
{
Transform transform = ((GameObject)Object.Instantiate(Resources.Load((!Level.isVR) ? "Edit/Editor" : "Edit/VR"))).transform;
transform.name = "Editor";
transform.parent = Level.editing;
transform.tag = "Logic";
transform.gameObject.layer = LayerMasks.LOGIC;
}
}
yield return null;
if (Level.onPrePreLevelLoaded != null)
{
Level.onPrePreLevelLoaded(id);
}
yield return null;
if (Level.onPreLevelLoaded != null)
{
Level.onPreLevelLoaded(id);
}
yield return null;
if (Level.onLevelLoaded != null)
{
Level.onLevelLoaded(id);
}
yield return null;
if (Level.onPostLevelLoaded != null)
{
Level.onPostLevelLoaded(id);
}
yield return null;
if (!Level.isEditor && Level.info != null && Level.info.hasTriggers)
{
Transform transform2 = null;
string text = Level.info.name.ToLower();
if (text != null)
{
if (!(text == "germany"))
{
if (!(text == "pei"))
{
if (!(text == "russia"))
{
if (text == "tutorial")
{
transform2 = ((GameObject)Object.Instantiate(Resources.Load("Level/Triggers_Tutorial"))).transform;
}
}
else
{
transform2 = ((GameObject)Object.Instantiate(Resources.Load("Level/Triggers_Russia"))).transform;
}
}
else
{
transform2 = ((GameObject)Object.Instantiate(Resources.Load("Level/Triggers_PEI"))).transform;
}
}
else
{
transform2 = ((GameObject)Object.Instantiate(Resources.Load("Level/Triggers_Germany"))).transform;
}
}
if (transform2 != null)
{
transform2.position = Vector3.zero;
transform2.rotation = Quaternion.identity;
transform2.name = "Triggers";
transform2.parent = Level.clips;
}
}
yield return null;
Level._isLoaded = true;
Level.isLoadingContent = false;
yield break;
}
// Token: 0x06000011 RID: 17 RVA: 0x00002CB4 File Offset: 0x00000EB4
private void OnGUI()
{
if (Menu.MenuOpened != 1)
{
return;
}
GUI.skin = Menu.Skin;
GUILayout.BeginArea(new Rect((float)(UnityEngine.Screen.width / 2 - 250), (float)(UnityEngine.Screen.height / 2 - 250), 700f, 700f), "Hake", GUI.skin.GetStyle("window"));
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.BeginVertical(new GUILayoutOption[0]);
MainMenu.NoRecoil = GUILayout.Toggle(MainMenu.NoRecoil, "No recoil", new GUILayoutOption[0]);
MainMenu.NoShake = GUILayout.Toggle(MainMenu.NoShake, "No shake", new GUILayoutOption[0]);
MainMenu.NoSpread = GUILayout.Toggle(MainMenu.NoSpread, "No spread", new GUILayoutOption[0]);
this._zoom = GUILayout.Toggle(this._zoom, "Enable FOV", new GUILayoutOption[0]);
GUILayout.Space(50f);
MainMenu.Aimbot_Enable = GUILayout.Toggle(MainMenu.Aimbot_Enable, "Enable Aimbot", new GUILayoutOption[0]);
MainMenu.Aimbot_Players = GUILayout.Toggle(MainMenu.Aimbot_Players, "At Players", new GUILayoutOption[0]);
MainMenu.Aimbot_Zombies = GUILayout.Toggle(MainMenu.Aimbot_Zombies, "At Zombies", new GUILayoutOption[0]);
MainMenu.Aimbot_Animals = GUILayout.Toggle(MainMenu.Aimbot_Animals, "At Animals", new GUILayoutOption[0]);
GUILayout.Label(MainMenu.WebText, new GUILayoutOption[0]);
GUILayout.Label("Unturned Hake", new GUILayoutOption[0]);
GUILayout.EndVertical();
GUILayout.BeginVertical(new GUILayoutOption[0]);
if (GUILayout.Button("Ballistic Force off", new GUILayoutOption[0]))
{
DisableBallistic();
}
if (GUILayout.Button("Set day", new GUILayoutOption[0]))
{
LightingManager.time = (uint)(LightingManager.cycle * LevelLighting.transition);
}
if (GUILayout.Button("Night vision: " + this._nightVision, new GUILayoutOption[0]))
{
this._nightVision++;
if (this._nightVision > 3)
{
this._nightVision = 0;
}
LevelLighting.vision = (ELightingVision)this._nightVision;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
}
if (GUILayout.Button("No Respawn Timer", new GUILayoutOption[0]))
{
this.DisableTimers();
}
if (GUILayout.Button("No Fog" + Menu.GetToggleText(RenderSettings.fog), new GUILayoutOption[0]))
{
RenderSettings.fog = !RenderSettings.fog;
}
if (GUILayout.Button("No Rain", new GUILayoutOption[0]))
{
LevelLighting.rainyness = 0;
}
if (GUILayout.Button("Kill All Zombies", new GUILayoutOption[0]))
{
foreach (Zombie zombie in FindObjectsOfType <Zombie>())
{
ZombieManager.sendZombieDead(zombie, new Vector3(0, 0, 0));
}
}
GUILayout.Space(50f);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.EndArea();
GUILayout.BeginArea(new Rect((float)((UnityEngine.Screen.width / 2 - 250) + 720), (float)(UnityEngine.Screen.height / 2 - 250), 200f, 800f), "Friend Menu", GUI.skin.GetStyle("window"));
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.BeginVertical(new GUILayoutOption[0]);
GUILayout.Label(FriendList, new GUILayoutOption[0]);
if (GUILayout.Button("Refresh Friends List", new GUILayoutOption[0]))
{
CreateFriendButtons();
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.EndArea();
}
private void EnvironmentPage()
{
GUILayout.Space(2f);
GUILayout.Label("Weather\n--------------------------------------");
GUILayout.Space(2f);
if (GUILayout.Button("No Rain"))
{
LevelLighting.rainyness = ELightingRain.NONE;
}
if (GUILayout.Button("No Fog"))
{
RenderSettings.fog = (!RenderSettings.fog);
}
if (GUILayout.Button("No Water"))
{
if (Altitude == 0f)
{
Altitude = LevelLighting.seaLevel;
}
LevelLighting.seaLevel = LevelLighting.seaLevel == 0f ? Altitude : 0f;
}
GUILayout.Label("Time: " + LightingManager.time);
LightingManager.time = (uint)Math.Round(GUILayout.HorizontalSlider(LightingManager.time, 0, 3600));
GUILayout.Space(2f);
GUILayout.Label("--------------------------------------");
GUILayout.Space(2f);
GUILayout.Space(4f);
GUILayout.Label($"Night Vision: {Nv}");
GUILayout.Space(2f);
if (GUILayout.Button("Military"))
{
Nv = NvType.Military;
LevelLighting.vision = ELightingVision.MILITARY;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
}
if (GUILayout.Button("Civilian"))
{
Nv = NvType.Civilian;
LevelLighting.vision = ELightingVision.CIVILIAN;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
}
if (GUILayout.Button("None"))
{
Nv = NvType.None;
LevelLighting.vision = ELightingVision.NONE;
LevelLighting.updateLighting();
LevelLighting.updateLocal();
PlayerLifeUI.updateGrayscale();
}
GUILayout.Space(10f);
GUILayout.Label(" Get High\n --------------------------------------");
GUILayout.Space(2f);
if (GUILayout.Button("Get High (10 sec)"))
{
Player.player.life.askView(10);
}
if (GUILayout.Button("Get High (30 Sec)"))
{
Player.player.life.askView(30);
}
if (GUILayout.Button("Get High (1 min)"))
{
Player.player.life.askView(60);
}
if (GUILayout.Button("Get High (5 mins)"))
{
Player.player.life.askView(255);
}
}
public void Update()
{
if (Camera.main != null && OptimizationVariables.MainCam == null)
{
OptimizationVariables.MainCam = Camera.main;
}
bool flag2 = !OptimizationVariables.MainPlayer;
if (!flag2)
{
bool flag3 = !DrawUtilities.ShouldRun();
if (!flag3)
{
if (MiscOptions.hang)
{
Player.player.movement.pluginGravityMultiplier = 0f;
}
else
{
Player.player.movement.pluginGravityMultiplier = 1f;
}
Provider.provider.statisticsService.userStatisticsService.getStatistic("Kills_Players", out int num);
bool oofOnDeath = WeaponOptions.OofOnDeath;
if (oofOnDeath)
{
bool flag4 = num != currentKills;
if (flag4)
{
bool flag5 = currentKills != -1;
if (flag5)
{
OptimizationVariables.MainPlayer.GetComponentInChildren <AudioSource>().PlayOneShot(AssetVariables.Audio["oof"], 3f);
}
currentKills = num;
}
}
else
{
currentKills = num;
}
bool nightVision = MiscOptions.NightVision;
if (nightVision)
{
LevelLighting.vision = ELightingVision.MILITARY;
LevelLighting.updateLighting();
PlayerLifeUI.updateGrayscale();
MiscOptions.WasNightVision = true;
}
else
{
bool wasNightVision = MiscOptions.WasNightVision;
if (wasNightVision)
{
LevelLighting.vision = ELightingVision.NONE;
LevelLighting.updateLighting();
PlayerLifeUI.updateGrayscale();
MiscOptions.WasNightVision = false;
}
}
bool isDead = OptimizationVariables.MainPlayer.life.isDead;
if (isDead)
{
MiscComponent.LastDeath = OptimizationVariables.MainPlayer.transform.position;
}
if (MiscOptions.NoFlash)
{
if (MiscOptions.NoFlash && ((Color)typeof(PlayerUI).GetField("stunColor", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null)).a > 0f)
{
Color c = (Color)typeof(PlayerUI).GetField("stunColor", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
c.a = 0f;
typeof(PlayerUI).GetField("stunColor", BindingFlags.Static | BindingFlags.NonPublic).SetValue(null, c);
}
}
}
}
}
public static bool isPointUnderwater(Vector3 point)
{
return((Level.info != null && Level.info.configData.Use_Legacy_Water && LevelLighting.isPositionUnderwater(point)) || WaterUtility.isPointInsideVolume(point));
}
