r2mods/ilspy_dump/ror2_csproj/RoR2/CharacterModel.cs

1544 lines
45 KiB
C#
Raw Normal View History

2024-10-04 07:26:37 +00:00
using System;
using System.Collections.Generic;
using System.Linq;
using RoR2.UI;
using RoR2.WwiseUtils;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Rendering;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.Serialization;
namespace RoR2;
public class CharacterModel : MonoBehaviour
{
[Serializable]
public struct RendererInfo : IEquatable<RendererInfo>
{
[PrefabReference]
public Renderer renderer;
public Material defaultMaterial;
public ShadowCastingMode defaultShadowCastingMode;
public bool ignoreOverlays;
public bool hideOnDeath;
public bool Equals(RendererInfo other)
{
if ((object)renderer == other.renderer && (object)defaultMaterial == other.defaultMaterial && object.Equals(defaultShadowCastingMode, other.defaultShadowCastingMode) && object.Equals(ignoreOverlays, other.ignoreOverlays))
{
return object.Equals(hideOnDeath, other.hideOnDeath);
}
return false;
}
}
[Serializable]
public struct LightInfo
{
public Light light;
public Color defaultColor;
public LightInfo(Light light)
{
this.light = light;
defaultColor = light.color;
}
}
private struct HurtBoxInfo
{
public readonly Transform transform;
public readonly float estimatedRadius;
public HurtBoxInfo(HurtBox hurtBox)
{
transform = hurtBox.transform;
estimatedRadius = Util.SphereVolumeToRadius(hurtBox.volume);
}
}
private struct ParentedPrefabDisplay
{
public ItemIndex itemIndex;
public EquipmentIndex equipmentIndex;
public GameObject instance { get; private set; }
public ItemDisplay itemDisplay { get; private set; }
public void Apply(CharacterModel characterModel, GameObject prefab, Transform parent, Vector3 localPosition, Quaternion localRotation, Vector3 localScale)
{
instance = UnityEngine.Object.Instantiate(prefab.gameObject, parent);
instance.transform.localPosition = localPosition;
instance.transform.localRotation = localRotation;
instance.transform.localScale = localScale;
LimbMatcher component = instance.GetComponent<LimbMatcher>();
if ((bool)component && (bool)characterModel.childLocator)
{
component.SetChildLocator(characterModel.childLocator);
}
itemDisplay = instance.GetComponent<ItemDisplay>();
}
public void Undo()
{
if ((bool)instance)
{
UnityEngine.Object.Destroy(instance);
instance = null;
}
}
}
private struct LimbMaskDisplay
{
public ItemIndex itemIndex;
public EquipmentIndex equipmentIndex;
public LimbFlags maskValue;
public void Apply(CharacterModel characterModel, LimbFlags mask)
{
maskValue = mask;
characterModel.limbFlagSet.AddFlags(mask);
}
public void Undo(CharacterModel characterModel)
{
characterModel.limbFlagSet.RemoveFlags(maskValue);
}
}
[Serializable]
private class LimbFlagSet
{
private readonly byte[] flagCounts = new byte[5];
private LimbFlags flags;
private static readonly int[] primeConversionTable;
public int materialMaskValue { get; private set; }
public LimbFlagSet()
{
materialMaskValue = 1;
}
static LimbFlagSet()
{
int[] array = new int[5] { 2, 3, 5, 11, 17 };
primeConversionTable = new int[31];
for (int i = 0; i < primeConversionTable.Length; i++)
{
int num = 1;
for (int j = 0; j < 5; j++)
{
if ((i & (1 << j)) != 0)
{
num *= array[j];
}
}
primeConversionTable[i] = num;
}
}
private static int ConvertLimbFlagsToMaterialMask(LimbFlags limbFlags)
{
return primeConversionTable[(int)limbFlags];
}
public void AddFlags(LimbFlags addedFlags)
{
LimbFlags limbFlags = flags;
flags |= addedFlags;
for (int i = 0; i < 5; i++)
{
if (((uint)addedFlags & (uint)(1 << i)) != 0)
{
flagCounts[i]++;
}
}
if (flags != limbFlags)
{
materialMaskValue = ConvertLimbFlagsToMaterialMask(flags);
}
}
public void RemoveFlags(LimbFlags removedFlags)
{
LimbFlags limbFlags = flags;
for (int i = 0; i < 5; i++)
{
if (((uint)removedFlags & (uint)(1 << i)) != 0 && --flagCounts[i] == 0)
{
flags &= (LimbFlags)(~(1 << i));
}
}
if (flags != limbFlags)
{
materialMaskValue = ConvertLimbFlagsToMaterialMask(flags);
}
}
}
public CharacterBody body;
public ItemDisplayRuleSet itemDisplayRuleSet;
public bool autoPopulateLightInfos = true;
public List<Transform> gameObjectActivationTransforms = new List<Transform>();
[FormerlySerializedAs("rendererInfos")]
public RendererInfo[] baseRendererInfos = Array.Empty<RendererInfo>();
public LightInfo[] baseLightInfos = Array.Empty<LightInfo>();
private ChildLocator childLocator;
private GameObject goldAffixEffect;
private HurtBoxInfo[] hurtBoxInfos = Array.Empty<HurtBoxInfo>();
private Transform coreTransform;
private static readonly Color hitFlashBaseColor;
private static readonly Color hitFlashShieldColor;
private static readonly Color healFlashColor;
private static readonly float hitFlashDuration;
private static readonly float healFlashDuration;
private VisibilityLevel _visibility = VisibilityLevel.Visible;
private bool _isGhost;
private bool _isDoppelganger;
private bool _isEcho;
[NonSerialized]
[HideInInspector]
public int invisibilityCount;
[NonSerialized]
public List<TemporaryOverlayInstance> temporaryOverlays = new List<TemporaryOverlayInstance>();
private bool materialsDirty = true;
private MaterialPropertyBlock propertyStorage;
private EquipmentIndex inventoryEquipmentIndex = EquipmentIndex.None;
private EliteIndex myEliteIndex = EliteIndex.None;
private float fade = 1f;
private float firstPersonFade = 1f;
public float corpseFade = 1f;
public bool CharacterOnScreen;
private SkinnedMeshRenderer mainSkinnedMeshRenderer;
public RendererVisiblity visibilityChecker;
private static readonly Color poisonEliteLightColor;
private static readonly Color hauntedEliteLightColor;
private static readonly Color lunarEliteLightColor;
private static readonly Color voidEliteLightColor;
private Color? lightColorOverride;
private Material particleMaterialOverride;
private GameObject poisonAffixEffect;
private GameObject hauntedAffixEffect;
private GameObject voidAffixEffect;
private float affixHauntedCloakLockoutDuration = 3f;
private EquipmentIndex currentEquipmentDisplayIndex = EquipmentIndex.None;
private ItemMask enabledItemDisplays;
private List<ParentedPrefabDisplay> parentedPrefabDisplays = new List<ParentedPrefabDisplay>();
private List<LimbMaskDisplay> limbMaskDisplays = new List<LimbMaskDisplay>();
private LimbFlagSet limbFlagSet = new LimbFlagSet();
public static Material revealedMaterial;
public static Material cloakedMaterial;
public static Material ghostMaterial;
public static Material bellBuffMaterial;
public static Material wolfhatMaterial;
public static Material energyShieldMaterial;
public static Material fullCritMaterial;
public static Material beetleJuiceMaterial;
public static Material brittleMaterial;
public static Material clayGooMaterial;
public static Material slow80Material;
public static Material immuneMaterial;
public static Material elitePoisonOverlayMaterial;
public static Material elitePoisonParticleReplacementMaterial;
public static Material eliteHauntedOverlayMaterial;
public static Material eliteJustHauntedOverlayMaterial;
public static Material eliteHauntedParticleReplacementMaterial;
public static Material eliteLunarParticleReplacementMaterial;
public static Material eliteVoidParticleReplacementMaterial;
public static Material eliteVoidOverlayMaterial;
public static Material weakMaterial;
public static Material pulverizedMaterial;
public static Material doppelgangerMaterial;
public static Material ghostParticleReplacementMaterial;
public static Material lunarGolemShieldMaterial;
public static Material echoMaterial;
public static Material gummyCloneMaterial;
public static Material voidSurvivorCorruptMaterial;
public static Material voidShieldMaterial;
public static Material growthNectarMaterial;
public static Material eliteAurelioniteAffixOverlay;
public static Material yesChefHeatMaterial;
private static readonly int maxOverlays;
private Material[] currentOverlays = new Material[maxOverlays];
private int activeOverlayCount;
private bool wasPreviouslyClayGooed;
private bool wasPreviouslyHaunted;
private RtpcSetter rtpcEliteEnemy;
private int shaderEliteRampIndex = -1;
private bool eliteChanged;
public int activeOverlays;
public int oldOverlays;
public float hitFlashValue;
public float healFlashValue;
public float oldHit;
public float oldHeal;
public float oldFade;
private EliteIndex oldEliteIndex = EliteIndex.None;
public bool forceUpdate;
private static Material[][] sharedMaterialArrays;
private static readonly int maxMaterials;
public VisibilityLevel visibility
{
get
{
return _visibility;
}
set
{
if (_visibility != value)
{
_visibility = value;
materialsDirty = true;
}
}
}
public bool isGhost
{
get
{
return _isGhost;
}
set
{
if (_isGhost != value)
{
_isGhost = value;
materialsDirty = true;
}
}
}
public bool isDoppelganger
{
get
{
return _isDoppelganger;
}
set
{
if (_isDoppelganger != value)
{
_isDoppelganger = value;
materialsDirty = true;
}
}
}
public bool isEcho
{
get
{
return _isEcho;
}
set
{
if (_isEcho != value)
{
_isEcho = value;
materialsDirty = true;
}
}
}
private void Awake()
{
enabledItemDisplays = ItemMask.Rent();
childLocator = GetComponent<ChildLocator>();
HurtBoxGroup component = GetComponent<HurtBoxGroup>();
coreTransform = base.transform;
if ((bool)component)
{
coreTransform = component.mainHurtBox?.transform ?? coreTransform;
HurtBox[] hurtBoxes = component.hurtBoxes;
if (hurtBoxes.Length != 0)
{
hurtBoxInfos = new HurtBoxInfo[hurtBoxes.Length];
for (int i = 0; i < hurtBoxes.Length; i++)
{
hurtBoxInfos[i] = new HurtBoxInfo(hurtBoxes[i]);
}
}
}
propertyStorage = new MaterialPropertyBlock();
RendererInfo[] array = baseRendererInfos;
for (int j = 0; j < array.Length; j++)
{
RendererInfo rendererInfo = array[j];
if (rendererInfo.renderer is SkinnedMeshRenderer)
{
mainSkinnedMeshRenderer = (SkinnedMeshRenderer)rendererInfo.renderer;
break;
}
}
if ((bool)body && Util.IsPrefab(body.gameObject) && !Util.IsPrefab(base.gameObject))
{
body = null;
}
}
private void Start()
{
forceUpdate = true;
visibility = VisibilityLevel.Invisible;
UpdateMaterials();
}
private void OnEnable()
{
InstanceTracker.Add(this);
if ((object)body != null)
{
rtpcEliteEnemy = new RtpcSetter("eliteEnemy", body.gameObject);
body.onInventoryChanged += OnInventoryChanged;
}
}
private void OnDisable()
{
InstanceUpdate();
if ((object)body != null)
{
body.onInventoryChanged -= OnInventoryChanged;
}
InstanceTracker.Remove(this);
}
public void SetVisible(bool visible)
{
if ((bool)body)
{
body.CharacterIsVisible = (CharacterOnScreen = visible);
}
}
private void OnDestroy()
{
ItemMask.Return(enabledItemDisplays);
}
private void OnInventoryChanged()
{
if ((bool)body)
{
Inventory inventory = body.inventory;
if ((bool)inventory)
{
UpdateItemDisplay(inventory);
inventoryEquipmentIndex = inventory.GetEquipmentIndex();
SetEquipmentDisplay(inventoryEquipmentIndex);
forceUpdate = true;
}
}
}
private void InstanceUpdate()
{
if (isGhost)
{
particleMaterialOverride = ghostParticleReplacementMaterial;
}
else if (myEliteIndex == RoR2Content.Elites.Poison.eliteIndex)
{
lightColorOverride = poisonEliteLightColor;
particleMaterialOverride = elitePoisonParticleReplacementMaterial;
}
else if (myEliteIndex == RoR2Content.Elites.Haunted.eliteIndex)
{
lightColorOverride = hauntedEliteLightColor;
particleMaterialOverride = eliteHauntedParticleReplacementMaterial;
}
else if (myEliteIndex == RoR2Content.Elites.Lunar.eliteIndex)
{
lightColorOverride = lunarEliteLightColor;
particleMaterialOverride = eliteLunarParticleReplacementMaterial;
}
else if (myEliteIndex == DLC1Content.Elites.Void.eliteIndex && (bool)body && body.healthComponent.alive)
{
lightColorOverride = voidEliteLightColor;
particleMaterialOverride = eliteVoidParticleReplacementMaterial;
}
else
{
lightColorOverride = null;
particleMaterialOverride = null;
}
UpdateGoldAffix();
UpdatePoisonAffix();
UpdateHauntedAffix();
UpdateVoidAffix();
UpdateLights();
}
private void UpdateLights()
{
LightInfo[] array = baseLightInfos;
if (array.Length == 0)
{
return;
}
if (lightColorOverride.HasValue)
{
Color value = lightColorOverride.Value;
for (int i = 0; i < array.Length; i++)
{
array[i].light.color = value;
}
}
else
{
for (int j = 0; j < array.Length; j++)
{
ref LightInfo reference = ref array[j];
reference.light.color = reference.defaultColor;
}
}
}
[InitDuringStartup]
private static void Init()
{
RoR2Application.onLateUpdate += StaticUpdate;
}
private static void StaticUpdate()
{
foreach (CharacterModel instances in InstanceTracker.GetInstancesList<CharacterModel>())
{
instances.InstanceUpdate();
}
}
public void AddTempOverlay(TemporaryOverlayInstance overlay)
{
temporaryOverlays.Add(overlay);
materialsDirty = true;
}
public void RemoveTempOverlay(TemporaryOverlayInstance overlay)
{
temporaryOverlays.Remove(overlay);
materialsDirty = true;
}
private bool IsCurrentEliteType(EliteDef eliteDef)
{
if ((object)eliteDef == null || eliteDef.eliteIndex == EliteIndex.None)
{
return false;
}
return eliteDef.eliteIndex == myEliteIndex;
}
private void UpdateGoldAffix()
{
if (IsCurrentEliteType(JunkContent.Elites.Gold) == (bool)goldAffixEffect)
{
return;
}
if (!goldAffixEffect)
{
goldAffixEffect = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/GoldAffixEffect"), base.transform);
ParticleSystem.ShapeModule shape = goldAffixEffect.GetComponent<ParticleSystem>().shape;
if ((bool)mainSkinnedMeshRenderer)
{
shape.shapeType = ParticleSystemShapeType.SkinnedMeshRenderer;
shape.skinnedMeshRenderer = mainSkinnedMeshRenderer;
}
}
else
{
UnityEngine.Object.Destroy(goldAffixEffect);
goldAffixEffect = null;
}
}
private void UpdatePoisonAffix()
{
if ((myEliteIndex == RoR2Content.Elites.Poison.eliteIndex && body.healthComponent.alive) == (bool)poisonAffixEffect)
{
return;
}
if (!poisonAffixEffect)
{
poisonAffixEffect = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/PoisonAffixEffect"), base.transform);
if ((bool)mainSkinnedMeshRenderer)
{
JitterBones[] components = poisonAffixEffect.GetComponents<JitterBones>();
for (int i = 0; i < components.Length; i++)
{
components[i].skinnedMeshRenderer = mainSkinnedMeshRenderer;
}
}
}
else
{
UnityEngine.Object.Destroy(poisonAffixEffect);
poisonAffixEffect = null;
}
}
private void UpdateHauntedAffix()
{
if ((myEliteIndex == RoR2Content.Elites.Haunted.eliteIndex && body.healthComponent.alive) == (bool)hauntedAffixEffect)
{
return;
}
if (!hauntedAffixEffect)
{
hauntedAffixEffect = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/HauntedAffixEffect"), base.transform);
if ((bool)mainSkinnedMeshRenderer)
{
JitterBones[] components = hauntedAffixEffect.GetComponents<JitterBones>();
for (int i = 0; i < components.Length; i++)
{
components[i].skinnedMeshRenderer = mainSkinnedMeshRenderer;
}
}
}
else
{
UnityEngine.Object.Destroy(hauntedAffixEffect);
hauntedAffixEffect = null;
}
}
private void UpdateVoidAffix()
{
if ((myEliteIndex == DLC1Content.Elites.Void.eliteIndex && body.healthComponent.alive) == (bool)voidAffixEffect)
{
return;
}
if (!voidAffixEffect)
{
voidAffixEffect = UnityEngine.Object.Instantiate(Addressables.LoadAssetAsync<GameObject>("RoR2/DLC1/EliteVoid/VoidAffixEffect.prefab").WaitForCompletion(), base.transform);
if ((bool)mainSkinnedMeshRenderer)
{
JitterBones[] components = voidAffixEffect.GetComponents<JitterBones>();
for (int i = 0; i < components.Length; i++)
{
components[i].skinnedMeshRenderer = mainSkinnedMeshRenderer;
}
}
}
else
{
UnityEngine.Object.Destroy(voidAffixEffect);
voidAffixEffect = null;
}
}
private void OnValidate()
{
if (Application.isPlaying)
{
return;
}
for (int i = 0; i < baseLightInfos.Length; i++)
{
ref LightInfo reference = ref baseLightInfos[i];
if ((bool)reference.light)
{
reference.defaultColor = reference.light.color;
}
}
_ = (bool)itemDisplayRuleSet;
if (autoPopulateLightInfos)
{
LightInfo[] first = (from light in GetComponentsInChildren<Light>()
select new LightInfo(light)).ToArray();
if (!first.SequenceEqual(baseLightInfos))
{
baseLightInfos = first;
}
}
}
private static void RefreshObstructorsForCamera(CameraRigController cameraRigController)
{
Vector3 position = cameraRigController.transform.position;
foreach (CharacterModel instances in InstanceTracker.GetInstancesList<CharacterModel>())
{
if (cameraRigController.enableFading)
{
float nearestHurtBoxDistance = instances.GetNearestHurtBoxDistance(position);
instances.fade = Mathf.Clamp01(Util.Remap(nearestHurtBoxDistance, cameraRigController.fadeStartDistance, cameraRigController.fadeEndDistance, 0f, 1f));
}
else
{
instances.fade = 1f;
}
}
}
private float GetNearestHurtBoxDistance(Vector3 cameraPosition)
{
float num = float.PositiveInfinity;
for (int i = 0; i < hurtBoxInfos.Length; i++)
{
float num2 = Vector3.Distance(hurtBoxInfos[i].transform.position, cameraPosition) - hurtBoxInfos[i].estimatedRadius;
if (num2 < num)
{
num = Mathf.Min(num2, num);
}
}
return num;
}
private void UpdateForCamera(CameraRigController cameraRigController)
{
VisibilityLevel num = visibility;
visibility = VisibilityLevel.Visible;
float target = 1f;
if ((bool)body)
{
if ((object)cameraRigController.firstPersonTarget == body.gameObject)
{
target = 0f;
}
visibility = body.GetVisibilityLevel(cameraRigController.targetTeamIndex);
}
float num2 = 0.25f;
if ((bool)cameraRigController.targetParams && cameraRigController.targetParams.currentCameraParamsData.overrideFirstPersonFadeDuration > 0f)
{
num2 = cameraRigController.targetParams.currentCameraParamsData.overrideFirstPersonFadeDuration;
}
firstPersonFade = Mathf.MoveTowards(firstPersonFade, target, Time.deltaTime / num2);
fade *= firstPersonFade * corpseFade;
if (fade <= 0f || invisibilityCount > 0)
{
visibility = VisibilityLevel.Invisible;
}
if (num != visibility)
{
forceUpdate = true;
}
bool flag = forceUpdate;
if (!flag)
{
for (int i = 0; i < baseRendererInfos.Length; i++)
{
if ((bool)baseRendererInfos[i].renderer && baseRendererInfos[i].renderer.isVisible)
{
flag = true;
break;
}
}
}
if (flag)
{
UpdateOverlays();
if (materialsDirty)
{
UpdateMaterials();
materialsDirty = false;
}
}
}
static CharacterModel()
{
hitFlashBaseColor = new Color32(193, 108, 51, byte.MaxValue);
hitFlashShieldColor = new Color32(132, 159, byte.MaxValue, byte.MaxValue);
healFlashColor = new Color32(104, 196, 49, byte.MaxValue);
hitFlashDuration = 0.15f;
healFlashDuration = 0.35f;
poisonEliteLightColor = new Color32(90, byte.MaxValue, 193, 204);
hauntedEliteLightColor = new Color32(152, 228, 217, 204);
lunarEliteLightColor = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, 127);
voidEliteLightColor = new Color32(151, 78, 132, 204);
maxOverlays = 6;
maxMaterials = 1 + maxOverlays;
SceneCamera.onSceneCameraPreRender += OnSceneCameraPreRender;
}
private static void OnSceneCameraPreRender(SceneCamera sceneCamera)
{
if ((bool)sceneCamera.cameraRigController)
{
RefreshObstructorsForCamera(sceneCamera.cameraRigController);
}
if (!sceneCamera.cameraRigController)
{
return;
}
foreach (CharacterModel instances in InstanceTracker.GetInstancesList<CharacterModel>())
{
instances.UpdateForCamera(sceneCamera.cameraRigController);
}
}
private void InstantiateDisplayRuleGroup(DisplayRuleGroup displayRuleGroup, ItemIndex itemIndex, EquipmentIndex equipmentIndex)
{
if (displayRuleGroup.rules == null)
{
return;
}
for (int i = 0; i < displayRuleGroup.rules.Length; i++)
{
ItemDisplayRule itemDisplayRule = displayRuleGroup.rules[i];
switch (itemDisplayRule.ruleType)
{
case ItemDisplayRuleType.ParentedPrefab:
if ((bool)childLocator)
{
Transform transform = childLocator.FindChild(itemDisplayRule.childName);
if ((bool)transform)
{
ParentedPrefabDisplay parentedPrefabDisplay = default(ParentedPrefabDisplay);
parentedPrefabDisplay.itemIndex = itemIndex;
parentedPrefabDisplay.equipmentIndex = equipmentIndex;
ParentedPrefabDisplay item2 = parentedPrefabDisplay;
item2.Apply(this, itemDisplayRule.followerPrefab, transform, itemDisplayRule.localPos, Quaternion.Euler(itemDisplayRule.localAngles), itemDisplayRule.localScale);
parentedPrefabDisplays.Add(item2);
}
}
break;
case ItemDisplayRuleType.LimbMask:
{
LimbMaskDisplay limbMaskDisplay = default(LimbMaskDisplay);
limbMaskDisplay.itemIndex = itemIndex;
limbMaskDisplay.equipmentIndex = equipmentIndex;
LimbMaskDisplay item = limbMaskDisplay;
item.Apply(this, itemDisplayRule.limbMask);
limbMaskDisplays.Add(item);
break;
}
}
}
}
private void SetEquipmentDisplay(EquipmentIndex newEquipmentIndex)
{
if (newEquipmentIndex == currentEquipmentDisplayIndex)
{
return;
}
for (int num = parentedPrefabDisplays.Count - 1; num >= 0; num--)
{
if (parentedPrefabDisplays[num].equipmentIndex != EquipmentIndex.None)
{
parentedPrefabDisplays[num].Undo();
parentedPrefabDisplays.RemoveAt(num);
}
}
for (int num2 = limbMaskDisplays.Count - 1; num2 >= 0; num2--)
{
if (limbMaskDisplays[num2].equipmentIndex != EquipmentIndex.None)
{
limbMaskDisplays[num2].Undo(this);
limbMaskDisplays.RemoveAt(num2);
}
}
currentEquipmentDisplayIndex = newEquipmentIndex;
if ((bool)itemDisplayRuleSet)
{
DisplayRuleGroup equipmentDisplayRuleGroup = itemDisplayRuleSet.GetEquipmentDisplayRuleGroup(newEquipmentIndex);
InstantiateDisplayRuleGroup(equipmentDisplayRuleGroup, ItemIndex.None, newEquipmentIndex);
}
}
private void EnableItemDisplay(ItemIndex itemIndex)
{
if (!enabledItemDisplays.Contains(itemIndex))
{
enabledItemDisplays.Add(itemIndex);
if ((bool)itemDisplayRuleSet)
{
DisplayRuleGroup itemDisplayRuleGroup = itemDisplayRuleSet.GetItemDisplayRuleGroup(itemIndex);
InstantiateDisplayRuleGroup(itemDisplayRuleGroup, itemIndex, EquipmentIndex.None);
}
}
}
public void DisableAllItemDisplays()
{
ItemIndex itemIndex = ItemIndex.Count;
for (ItemIndex itemCount = (ItemIndex)ItemCatalog.itemCount; itemIndex < itemCount; itemIndex++)
{
DisableItemDisplay(itemIndex);
}
}
private void DisableItemDisplay(ItemIndex itemIndex)
{
if (!enabledItemDisplays.Contains(itemIndex))
{
return;
}
enabledItemDisplays.Remove(itemIndex);
for (int num = parentedPrefabDisplays.Count - 1; num >= 0; num--)
{
if (parentedPrefabDisplays[num].itemIndex == itemIndex)
{
parentedPrefabDisplays[num].Undo();
parentedPrefabDisplays.RemoveAt(num);
}
}
for (int num2 = limbMaskDisplays.Count - 1; num2 >= 0; num2--)
{
if (limbMaskDisplays[num2].itemIndex == itemIndex)
{
limbMaskDisplays[num2].Undo(this);
limbMaskDisplays.RemoveAt(num2);
}
}
}
public void UpdateItemDisplay(Inventory inventory)
{
ItemIndex itemIndex = ItemIndex.Count;
for (ItemIndex itemCount = (ItemIndex)ItemCatalog.itemCount; itemIndex < itemCount; itemIndex++)
{
if (inventory.GetItemCount(itemIndex) > 0)
{
EnableItemDisplay(itemIndex);
}
else
{
DisableItemDisplay(itemIndex);
}
}
}
public void HighlightItemDisplay(ItemIndex itemIndex)
{
if (!enabledItemDisplays.Contains(itemIndex))
{
return;
}
ItemTierDef itemTierDef = ItemTierCatalog.GetItemTierDef(ItemCatalog.GetItemDef(itemIndex).tier);
GameObject gameObject = null;
gameObject = ((!itemTierDef || !itemTierDef.highlightPrefab) ? LegacyResourcesAPI.Load<GameObject>("Prefabs/UI/HighlightTier1Item") : itemTierDef.highlightPrefab);
for (int num = parentedPrefabDisplays.Count - 1; num >= 0; num--)
{
if (parentedPrefabDisplays[num].itemIndex == itemIndex)
{
GameObject instance = parentedPrefabDisplays[num].instance;
if ((bool)instance)
{
Renderer componentInChildren = instance.GetComponentInChildren<Renderer>();
if ((bool)componentInChildren && (bool)body)
{
HighlightRect.CreateHighlight(body.gameObject, componentInChildren, gameObject);
}
}
}
}
}
public List<GameObject> GetEquipmentDisplayObjects(EquipmentIndex equipmentIndex)
{
List<GameObject> list = new List<GameObject>();
for (int num = parentedPrefabDisplays.Count - 1; num >= 0; num--)
{
if (parentedPrefabDisplays[num].equipmentIndex == equipmentIndex)
{
GameObject instance = parentedPrefabDisplays[num].instance;
list.Add(instance);
}
}
return list;
}
public List<GameObject> GetItemDisplayObjects(ItemIndex itemIndex)
{
List<GameObject> list = new List<GameObject>();
for (int num = parentedPrefabDisplays.Count - 1; num >= 0; num--)
{
if (parentedPrefabDisplays[num].itemIndex == itemIndex)
{
GameObject instance = parentedPrefabDisplays[num].instance;
list.Add(instance);
}
}
return list;
}
[InitDuringStartup]
private static void InitMaterials()
{
AsyncOperationHandle<Material> asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matEliteAurelioniteAffixOverlay");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
eliteAurelioniteAffixOverlay = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matRevealedEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
revealedMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matCloakedEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
cloakedMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matGhostEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
ghostMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matGhostParticleReplacement");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
ghostParticleReplacementMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matWolfhatOverlay");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
wolfhatMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matEnergyShield");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
energyShieldMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matBeetleJuice");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
beetleJuiceMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matBrittle");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
brittleMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matFullCrit");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
fullCritMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matClayGooDebuff");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
clayGooMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matSlow80Debuff");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
slow80Material = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matImmune");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
immuneMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matBellBuff");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
bellBuffMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matElitePoisonOverlay");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
elitePoisonOverlayMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matElitePoisonParticleReplacement");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
elitePoisonParticleReplacementMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matEliteHauntedOverlay");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
eliteHauntedOverlayMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matEliteHauntedParticleReplacement");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
eliteHauntedParticleReplacementMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matEliteJustHauntedOverlay");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
eliteJustHauntedOverlayMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matEliteLunarParticleReplacement");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
eliteLunarParticleReplacementMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matDoppelganger");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
doppelgangerMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matWeakOverlay");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
weakMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matPulverizedOverlay");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
pulverizedMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matLunarGolemShield");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
lunarGolemShieldMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matEcho");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
echoMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matGummyClone");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
gummyCloneMaterial = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<Material>("Materials/matGrowthNectarGlow");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
growthNectarMaterial = x.Result;
};
asyncOperationHandle = Addressables.LoadAssetAsync<Material>("RoR2/DLC1/EliteVoid/matEliteVoidParticleReplacement.mat");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
eliteVoidParticleReplacementMaterial = x.Result;
};
asyncOperationHandle = Addressables.LoadAssetAsync<Material>("RoR2/DLC1/EliteVoid/matEliteVoidOverlay.mat");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
eliteVoidOverlayMaterial = x.Result;
};
asyncOperationHandle = Addressables.LoadAssetAsync<Material>("RoR2/DLC1/VoidSurvivor/matVoidSurvivorCorruptOverlay.mat");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
voidSurvivorCorruptMaterial = x.Result;
};
asyncOperationHandle = Addressables.LoadAssetAsync<Material>("RoR2/DLC1/MissileVoid/matEnergyShieldVoid.mat");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
voidShieldMaterial = x.Result;
};
asyncOperationHandle = Addressables.LoadAssetAsync<Material>("RoR2/DLC2/Chef/matYesChefOverlay.mat");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<Material> x)
{
yesChefHeatMaterial = x.Result;
};
}
private bool UpdateOverlayStates()
{
oldOverlays = activeOverlays;
activeOverlays = 0;
if ((bool)body)
{
bool condition2 = body.HasBuff(RoR2Content.Buffs.ClayGoo);
Inventory inventory = body.inventory;
isGhost = (object)inventory != null && inventory.GetItemCount(RoR2Content.Items.Ghost) > 0;
myEliteIndex = EquipmentCatalog.GetEquipmentDef(inventoryEquipmentIndex)?.passiveBuffDef?.eliteDef?.eliteIndex ?? EliteIndex.None;
oldHit = hitFlashValue;
oldHeal = healFlashValue;
if ((bool)body.healthComponent)
{
hitFlashValue = Mathf.Clamp01(1f - body.healthComponent.timeSinceLastHit / hitFlashDuration);
healFlashValue = Mathf.Pow(Mathf.Clamp01(1f - body.healthComponent.timeSinceLastHeal / healFlashDuration), 0.5f);
}
eliteChanged = myEliteIndex != oldEliteIndex;
int num = 0;
SetOverlayFlag(num++, eliteChanged);
SetOverlayFlag(num++, hitFlashValue != oldHit || healFlashValue != oldHeal);
SetOverlayFlag(num++, isGhost);
SetOverlayFlag(num++, condition2);
SetOverlayFlag(num++, myEliteIndex == RoR2Content.Elites.Poison.eliteIndex || body.HasBuff(RoR2Content.Buffs.HealingDisabled));
SetOverlayFlag(num++, body.HasBuff(RoR2Content.Buffs.Weak));
SetOverlayFlag(num++, body.HasBuff(RoR2Content.Buffs.FullCrit));
SetOverlayFlag(num++, body.HasBuff(RoR2Content.Buffs.AttackSpeedOnCrit));
SetOverlayFlag(num++, (bool)body.healthComponent && body.healthComponent.shield > 0f);
SetOverlayFlag(num++, body.HasBuff(RoR2Content.Buffs.BeetleJuice));
SetOverlayFlag(num++, body.HasBuff(RoR2Content.Buffs.Immune));
SetOverlayFlag(num++, body.HasBuff(RoR2Content.Buffs.Slow80));
SetOverlayFlag(num++, (bool)body.inventory && body.inventory.GetItemCount(RoR2Content.Items.LunarDagger) > 0);
SetOverlayFlag(num++, (bool)body.inventory && body.inventory.GetItemCount(RoR2Content.Items.InvadingDoppelganger) > 0);
SetOverlayFlag(num++, body.HasBuff(RoR2Content.Buffs.AffixHaunted));
SetOverlayFlag(num++, body.HasBuff(DLC1Content.Buffs.EliteVoid) && (bool)body.healthComponent && body.healthComponent.alive);
SetOverlayFlag(num++, body.HasBuff(RoR2Content.Buffs.Pulverized));
SetOverlayFlag(num++, body.HasBuff(RoR2Content.Buffs.LunarShell));
SetOverlayFlag(num++, (bool)body.inventory && body.inventory.GetItemCount(RoR2Content.Items.SummonedEcho) > 0);
SetOverlayFlag(num++, IsGummyClone());
SetOverlayFlag(num++, body.HasBuff(DLC1Content.Buffs.VoidSurvivorCorruptMode));
SetOverlayFlag(num++, IsAurelioniteAffix());
SetOverlayFlag(num++, body.HasBuff(DLC2Content.Buffs.BoostAllStatsBuff));
SetOverlayFlag(num++, body.HasBuff(DLC2Content.Buffs.boostedFireEffect));
for (int i = 0; i < baseRendererInfos.Length; i++)
{
SetOverlayFlag(num + i, baseRendererInfos[i].ignoreOverlays);
}
}
bool flag = fade != oldFade;
oldEliteIndex = myEliteIndex;
oldFade = fade;
return oldOverlays != activeOverlays || flag;
void SetOverlayFlag(int index, bool condition)
{
if (condition)
{
activeOverlays |= 1 << index;
}
}
}
private void UpdateOverlays()
{
if (visibility == VisibilityLevel.Invisible || (!UpdateOverlayStates() && !forceUpdate))
{
return;
}
forceUpdate = false;
for (int i = 0; i < activeOverlayCount; i++)
{
currentOverlays[i] = null;
}
activeOverlayCount = 0;
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(inventoryEquipmentIndex);
myEliteIndex = equipmentDef?.passiveBuffDef?.eliteDef?.eliteIndex ?? EliteIndex.None;
shaderEliteRampIndex = equipmentDef?.passiveBuffDef?.eliteDef?.shaderEliteRampIndex ?? (-1);
bool flag = false;
bool flag2 = false;
if ((bool)body)
{
flag = body.HasBuff(RoR2Content.Buffs.ClayGoo);
flag2 = body.HasBuff(RoR2Content.Buffs.AffixHauntedRecipient);
rtpcEliteEnemy.value = ((myEliteIndex != EliteIndex.None) ? 1f : 0f);
rtpcEliteEnemy.FlushIfChanged();
Inventory inventory = body.inventory;
isGhost = (object)inventory != null && inventory.GetItemCount(RoR2Content.Items.Ghost) > 0;
Inventory inventory2 = body.inventory;
isDoppelganger = (object)inventory2 != null && inventory2.GetItemCount(RoR2Content.Items.InvadingDoppelganger) > 0;
Inventory inventory3 = body.inventory;
isEcho = (object)inventory3 != null && inventory3.GetItemCount(RoR2Content.Items.SummonedEcho) > 0;
Inventory inventory4 = body.inventory;
bool flag3 = (object)inventory4 != null && inventory4.GetItemCount(DLC1Content.Items.MissileVoid) > 0;
AddOverlay(ghostMaterial, isGhost);
AddOverlay(doppelgangerMaterial, isDoppelganger);
AddOverlay(clayGooMaterial, flag);
AddOverlay(elitePoisonOverlayMaterial, myEliteIndex == RoR2Content.Elites.Poison.eliteIndex || body.HasBuff(RoR2Content.Buffs.HealingDisabled));
AddOverlay(eliteHauntedOverlayMaterial, body.HasBuff(RoR2Content.Buffs.AffixHaunted));
AddOverlay(eliteVoidOverlayMaterial, body.HasBuff(DLC1Content.Buffs.EliteVoid) && (bool)body.healthComponent && body.healthComponent.alive);
AddOverlay(pulverizedMaterial, body.HasBuff(RoR2Content.Buffs.Pulverized));
AddOverlay(weakMaterial, body.HasBuff(RoR2Content.Buffs.Weak));
AddOverlay(fullCritMaterial, body.HasBuff(RoR2Content.Buffs.FullCrit));
AddOverlay(wolfhatMaterial, body.HasBuff(RoR2Content.Buffs.AttackSpeedOnCrit));
AddOverlay(flag3 ? voidShieldMaterial : energyShieldMaterial, (bool)body.healthComponent && body.healthComponent.shield > 0f);
AddOverlay(beetleJuiceMaterial, body.HasBuff(RoR2Content.Buffs.BeetleJuice));
AddOverlay(immuneMaterial, body.HasBuff(RoR2Content.Buffs.Immune));
AddOverlay(slow80Material, body.HasBuff(RoR2Content.Buffs.Slow80));
AddOverlay(brittleMaterial, (bool)body.inventory && body.inventory.GetItemCount(RoR2Content.Items.LunarDagger) > 0);
AddOverlay(lunarGolemShieldMaterial, body.HasBuff(RoR2Content.Buffs.LunarShell));
AddOverlay(echoMaterial, isEcho);
AddOverlay(gummyCloneMaterial, IsGummyClone());
AddOverlay(voidSurvivorCorruptMaterial, body.HasBuff(DLC1Content.Buffs.VoidSurvivorCorruptMode));
AddOverlay(growthNectarMaterial, body.HasBuff(DLC2Content.Buffs.BoostAllStatsBuff));
AddOverlay(eliteAurelioniteAffixOverlay, IsAurelioniteAffix());
AddOverlay(lunarGolemShieldMaterial, body.HasBuff(DLC2Content.Buffs.EliteBead));
AddOverlay(brittleMaterial, body.HasBuff(DLC2Content.Buffs.EliteBeadCorruption));
AddOverlay(yesChefHeatMaterial, body.HasBuff(DLC2Content.Buffs.boostedFireEffect));
}
if (wasPreviouslyClayGooed && !flag)
{
TemporaryOverlayInstance temporaryOverlayInstance = TemporaryOverlayManager.AddOverlay(base.gameObject);
temporaryOverlayInstance.duration = 0.6f;
temporaryOverlayInstance.animateShaderAlpha = true;
temporaryOverlayInstance.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
temporaryOverlayInstance.destroyComponentOnEnd = true;
temporaryOverlayInstance.originalMaterial = clayGooMaterial;
temporaryOverlayInstance.AddToCharacterModel(this);
}
if (wasPreviouslyHaunted != flag2)
{
TemporaryOverlayInstance temporaryOverlayInstance2 = TemporaryOverlayManager.AddOverlay(base.gameObject);
temporaryOverlayInstance2.duration = 0.5f;
temporaryOverlayInstance2.animateShaderAlpha = true;
temporaryOverlayInstance2.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
temporaryOverlayInstance2.destroyComponentOnEnd = true;
temporaryOverlayInstance2.originalMaterial = eliteJustHauntedOverlayMaterial;
temporaryOverlayInstance2.AddToCharacterModel(this);
}
wasPreviouslyClayGooed = flag;
wasPreviouslyHaunted = flag2;
for (int j = 0; j < temporaryOverlays.Count; j++)
{
if (activeOverlayCount >= maxOverlays)
{
break;
}
currentOverlays[activeOverlayCount++] = temporaryOverlays[j].materialInstance;
}
wasPreviouslyClayGooed = flag;
wasPreviouslyHaunted = flag2;
materialsDirty = true;
void AddOverlay(Material overlayMaterial, bool condition)
{
if (activeOverlayCount < maxOverlays && condition)
{
currentOverlays[activeOverlayCount++] = overlayMaterial;
}
}
}
[InitDuringStartup]
private static void InitSharedMaterialsArrays()
{
sharedMaterialArrays = new Material[maxMaterials + 1][];
if (maxMaterials > 0)
{
sharedMaterialArrays[0] = Array.Empty<Material>();
for (int i = 1; i < sharedMaterialArrays.Length; i++)
{
sharedMaterialArrays[i] = new Material[i];
}
}
}
private void UpdateRendererMaterials(Renderer renderer, Material defaultMaterial, bool ignoreOverlays)
{
Material material = null;
switch (visibility)
{
case VisibilityLevel.Invisible:
renderer.sharedMaterial = null;
return;
case VisibilityLevel.Cloaked:
if (!ignoreOverlays)
{
ignoreOverlays = true;
material = cloakedMaterial;
}
break;
case VisibilityLevel.Revealed:
if (!ignoreOverlays)
{
material = revealedMaterial;
}
break;
case VisibilityLevel.Visible:
material = (ignoreOverlays ? (particleMaterialOverride ? particleMaterialOverride : defaultMaterial) : ((!isDoppelganger) ? ((!isGhost) ? ((!IsGummyClone()) ? ((!IsAurelioniteAffix()) ? defaultMaterial : eliteAurelioniteAffixOverlay) : gummyCloneMaterial) : ghostMaterial) : doppelgangerMaterial));
break;
}
int num = ((!ignoreOverlays) ? activeOverlayCount : 0);
if ((bool)material)
{
num++;
}
Material material2 = null;
Material[] array = sharedMaterialArrays[num];
int num2 = 0;
if ((bool)material)
{
array[num2++] = material;
}
if (!ignoreOverlays)
{
for (int i = 0; i < activeOverlayCount; i++)
{
array[num2++] = currentOverlays[i];
}
}
if (material2 != null)
{
array[num2++] = material2;
}
if (num2 != array.Length)
{
Debug.LogError("Materials are going to be pink or something!?");
}
renderer.sharedMaterials = array;
}
private void UpdateMaterials()
{
Color value = Color.black;
if ((bool)body && (bool)body.healthComponent)
{
float num = Mathf.Clamp01(1f - body.healthComponent.timeSinceLastHit / hitFlashDuration);
float num2 = Mathf.Pow(Mathf.Clamp01(1f - body.healthComponent.timeSinceLastHeal / healFlashDuration), 0.5f);
value = ((!(num2 > num)) ? (((body.healthComponent.shield > 0f) ? hitFlashShieldColor : hitFlashBaseColor) * num) : (healFlashColor * num2));
}
if (visibility == VisibilityLevel.Invisible)
{
for (int num3 = baseRendererInfos.Length - 1; num3 >= 0; num3--)
{
RendererInfo rendererInfo = baseRendererInfos[num3];
rendererInfo.renderer.shadowCastingMode = ShadowCastingMode.Off;
rendererInfo.renderer.enabled = false;
}
}
else
{
for (int num4 = baseRendererInfos.Length - 1; num4 >= 0; num4--)
{
RendererInfo rendererInfo2 = baseRendererInfos[num4];
Renderer renderer = rendererInfo2.renderer;
UpdateRendererMaterials(renderer, baseRendererInfos[num4].defaultMaterial, baseRendererInfos[num4].ignoreOverlays);
renderer.shadowCastingMode = rendererInfo2.defaultShadowCastingMode;
renderer.enabled = true;
renderer.GetPropertyBlock(propertyStorage);
propertyStorage.SetColor(CommonShaderProperties._FlashColor, value);
propertyStorage.SetFloat(CommonShaderProperties._EliteIndex, shaderEliteRampIndex + 1);
propertyStorage.SetInt(CommonShaderProperties._LimbPrimeMask, limbFlagSet.materialMaskValue);
propertyStorage.SetFloat(CommonShaderProperties._Fade, fade);
renderer.SetPropertyBlock(propertyStorage);
}
}
for (int i = 0; i < parentedPrefabDisplays.Count; i++)
{
ItemDisplay itemDisplay = parentedPrefabDisplays[i].itemDisplay;
itemDisplay.SetVisibilityLevel(visibility);
for (int j = 0; j < itemDisplay.rendererInfos.Length; j++)
{
Renderer renderer2 = itemDisplay.rendererInfos[j].renderer;
renderer2.GetPropertyBlock(propertyStorage);
propertyStorage.SetColor(CommonShaderProperties._FlashColor, value);
propertyStorage.SetFloat(CommonShaderProperties._Fade, fade);
renderer2.SetPropertyBlock(propertyStorage);
}
}
}
private bool IsGummyClone()
{
CharacterBody characterBody = body;
if ((object)characterBody == null)
{
return false;
}
return characterBody.inventory?.GetItemCount(DLC1Content.Items.GummyCloneIdentifier) > 0;
}
private bool IsAurelioniteAffix()
{
bool result = false;
if ((bool)body)
{
result = body.HasBuff(DLC2Content.Buffs.EliteAurelionite);
}
return result;
}
public void OnDeath()
{
for (int i = 0; i < parentedPrefabDisplays.Count; i++)
{
parentedPrefabDisplays[i].itemDisplay.OnDeath();
}
InstanceUpdate();
UpdateOverlays();
UpdateMaterials();
}
}