r2mods/ilspy_dump/ror2_csproj/RoR2/DotController.cs

986 lines
25 KiB
C#
Raw Normal View History

2024-10-04 07:26:37 +00:00
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Runtime.InteropServices;
using HG;
using RoR2.Items;
using RoR2.Stats;
using UnityEngine;
using UnityEngine.Networking;
namespace RoR2;
public class DotController : NetworkBehaviour
{
public enum DotIndex
{
None = -1,
Bleed,
Burn,
Helfire,
PercentBurn,
Poison,
Blight,
SuperBleed,
StrongerBurn,
Fracture,
LunarRuin,
Count
}
public class DotDef
{
public float interval;
public float damageCoefficient;
public DamageColorIndex damageColorIndex;
public BuffDef associatedBuff;
public BuffDef terminalTimedBuff;
public float terminalTimedBuffDuration;
public bool resetTimerOnAdd;
}
private class DotStack
{
public DotIndex dotIndex;
public DotDef dotDef;
public GameObject attackerObject;
public TeamIndex attackerTeam;
public float timer;
public float damage;
public DamageTypeCombo damageType;
public void Reset()
{
dotIndex = DotIndex.Bleed;
dotDef = null;
attackerObject = null;
attackerTeam = TeamIndex.Neutral;
timer = 0f;
damage = 0f;
damageType = default(DamageTypeCombo);
}
}
private sealed class DotStackPool : BasePool<DotStack>
{
protected override void ResetItem(DotStack item)
{
item.Reset();
}
}
private class PendingDamage
{
public GameObject attackerObject;
public float totalDamage;
public DamageTypeCombo damageType;
public void Reset()
{
attackerObject = null;
totalDamage = 0f;
damageType = default(DamageTypeCombo);
}
}
private sealed class PendingDamagePool : BasePool<PendingDamage>
{
protected override void ResetItem(PendingDamage item)
{
item.Reset();
}
}
public delegate void OnDotInflictedServerGlobalDelegate(DotController dotController, ref InflictDotInfo inflictDotInfo);
public const float minDamagePerTick = 1f;
private static DotDef[] dotDefs;
private static readonly Dictionary<int, DotController> dotControllerLocator = new Dictionary<int, DotController>();
private static readonly List<DotController> instancesList = new List<DotController>();
public static readonly ReadOnlyCollection<DotController> readOnlyInstancesList = instancesList.AsReadOnly();
public static GameObject FractureImpactEffectPrefab;
public static GameObject HelfireIgniteEffectPrefab;
public static GameObject DotControllerPrefab;
[SyncVar]
private NetworkInstanceId victimObjectId;
private GameObject _victimObject;
private CharacterBody _victimBody;
private BurnEffectController burnEffectController;
private BurnEffectController strongerBurnEffectController;
private BurnEffectController helfireEffectController;
private BurnEffectController poisonEffectController;
private BurnEffectController blightEffectController;
private EffectManagerHelper bleedEffect;
private EffectManagerHelper superBleedEffect;
private EffectManagerHelper preFractureEffect;
[SyncVar]
private uint activeDotFlags;
private static readonly DotStackPool dotStackPool = new DotStackPool();
private List<DotStack> dotStackList;
private float[] dotTimers;
private static readonly PendingDamagePool pendingDamagePool = new PendingDamagePool();
private int recordedVictimInstanceId = -1;
public GameObject victimObject
{
get
{
if (!_victimObject)
{
if (NetworkServer.active)
{
_victimObject = NetworkServer.FindLocalObject(victimObjectId);
}
else if (NetworkClient.active)
{
_victimObject = ClientScene.FindLocalObject(victimObjectId);
}
}
return _victimObject;
}
set
{
NetworkvictimObjectId = value.GetComponent<NetworkIdentity>().netId;
}
}
private CharacterBody victimBody
{
get
{
if (!_victimBody && (bool)victimObject)
{
_victimBody = victimObject.GetComponent<CharacterBody>();
}
return _victimBody;
}
}
private HealthComponent victimHealthComponent => victimBody?.healthComponent;
private TeamIndex victimTeam
{
get
{
if (!victimBody)
{
return TeamIndex.None;
}
return victimBody.teamComponent.teamIndex;
}
}
public NetworkInstanceId NetworkvictimObjectId
{
get
{
return victimObjectId;
}
[param: In]
set
{
SetSyncVar(value, ref victimObjectId, 1u);
}
}
public uint NetworkactiveDotFlags
{
get
{
return activeDotFlags;
}
[param: In]
set
{
SetSyncVar(value, ref activeDotFlags, 2u);
}
}
public static event OnDotInflictedServerGlobalDelegate onDotInflictedServerGlobal;
public static DotDef GetDotDef(DotIndex dotIndex)
{
if (dotIndex < DotIndex.Bleed || dotIndex >= DotIndex.Count)
{
return null;
}
return dotDefs[(int)dotIndex];
}
[SystemInitializer(new Type[] { typeof(BuffCatalog) })]
private static void InitDotCatalog()
{
dotDefs = new DotDef[10];
dotDefs[0] = new DotDef
{
interval = 0.25f,
damageCoefficient = 0.2f,
damageColorIndex = DamageColorIndex.Bleed,
associatedBuff = RoR2Content.Buffs.Bleeding
};
dotDefs[1] = new DotDef
{
interval = 0.2f,
damageCoefficient = 0.1f,
damageColorIndex = DamageColorIndex.Item,
associatedBuff = RoR2Content.Buffs.OnFire,
terminalTimedBuff = RoR2Content.Buffs.OnFire,
terminalTimedBuffDuration = 1f
};
dotDefs[7] = new DotDef
{
interval = 0.2f,
damageCoefficient = 0.1f,
damageColorIndex = DamageColorIndex.Item,
associatedBuff = DLC1Content.Buffs.StrongerBurn,
terminalTimedBuff = DLC1Content.Buffs.StrongerBurn,
terminalTimedBuffDuration = 1f
};
dotDefs[3] = new DotDef
{
interval = 0.2f,
damageCoefficient = 0.1f,
damageColorIndex = DamageColorIndex.Item,
associatedBuff = RoR2Content.Buffs.OnFire
};
dotDefs[2] = new DotDef
{
interval = 0.2f,
damageCoefficient = 0.02f,
damageColorIndex = DamageColorIndex.Item
};
dotDefs[4] = new DotDef
{
interval = 0.333f,
damageCoefficient = 0.333f,
damageColorIndex = DamageColorIndex.Poison,
associatedBuff = RoR2Content.Buffs.Poisoned
};
dotDefs[5] = new DotDef
{
interval = 0.333f,
damageCoefficient = 0.2f,
damageColorIndex = DamageColorIndex.Poison,
associatedBuff = RoR2Content.Buffs.Blight
};
dotDefs[6] = new DotDef
{
interval = 0.25f,
damageCoefficient = 0.333f,
damageColorIndex = DamageColorIndex.SuperBleed,
associatedBuff = RoR2Content.Buffs.SuperBleed
};
dotDefs[8] = new DotDef
{
interval = 3f,
damageCoefficient = 4f,
damageColorIndex = DamageColorIndex.Void,
associatedBuff = DLC1Content.Buffs.Fracture,
resetTimerOnAdd = false
};
dotDefs[9] = new DotDef
{
interval = 3f,
damageCoefficient = 0f,
damageColorIndex = DamageColorIndex.Default,
associatedBuff = DLC2Content.Buffs.lunarruin,
resetTimerOnAdd = true
};
}
public bool HasDotActive(DotIndex dotIndex)
{
return (activeDotFlags & (1 << (int)dotIndex)) != 0;
}
private void Awake()
{
if (NetworkServer.active)
{
dotStackList = new List<DotStack>();
dotTimers = new float[10];
}
instancesList.Add(this);
}
private void OnDestroy()
{
if (NetworkServer.active)
{
for (int num = dotStackList.Count - 1; num >= 0; num--)
{
RemoveDotStackAtServer(num);
}
}
instancesList.Remove(this);
if (recordedVictimInstanceId != -1)
{
dotControllerLocator.Remove(recordedVictimInstanceId);
}
}
private void FixedUpdate()
{
if (!victimObject)
{
if (NetworkServer.active)
{
HandleDestroy();
}
return;
}
UpdateDotVisuals();
if (!NetworkServer.active)
{
return;
}
for (DotIndex dotIndex = DotIndex.Bleed; dotIndex < DotIndex.Count; dotIndex++)
{
uint num = (uint)(1 << (int)dotIndex);
if ((activeDotFlags & num) == 0)
{
continue;
}
DotDef dotDef = GetDotDef(dotIndex);
float num2 = dotTimers[(int)dotIndex] - Time.fixedDeltaTime;
if (num2 <= 0f)
{
num2 += dotDef.interval;
int remainingActive = 0;
EvaluateDotStacksForType(dotIndex, dotDef.interval, out remainingActive);
NetworkactiveDotFlags = activeDotFlags & ~num;
if (remainingActive != 0)
{
NetworkactiveDotFlags = activeDotFlags | num;
}
}
dotTimers[(int)dotIndex] = num2;
}
if (dotStackList.Count == 0)
{
HandleDestroy();
}
}
private void HandleDestroy()
{
RepoolEffect(ref bleedEffect);
RepoolEffect(ref superBleedEffect);
RepoolEffect(ref preFractureEffect);
UnityEngine.Object.Destroy(base.gameObject);
}
private EffectManagerHelper GetPooledEffect(string _path)
{
return EffectManager.GetAndActivatePooledEffect(LegacyResourcesAPI.Load<GameObject>(_path), base.transform, inResetLocal: true);
}
private void RepoolEffect(ref EffectManagerHelper emh)
{
if ((bool)emh)
{
if (emh.OwningPool != null)
{
emh.transform.SetParent(null);
emh.ReturnToPool();
}
else
{
UnityEngine.Object.Destroy(emh.gameObject);
}
emh = null;
}
}
private void UpdateDotVisuals()
{
if (!victimBody)
{
return;
}
ModelLocator modelLocator = null;
base.transform.position = victimBody.corePosition;
if ((activeDotFlags & (true ? 1u : 0u)) != 0)
{
if (!bleedEffect)
{
bleedEffect = GetPooledEffect("Prefabs/BleedEffect");
}
}
else if ((bool)bleedEffect)
{
RepoolEffect(ref bleedEffect);
}
if ((activeDotFlags & 2u) != 0 || (activeDotFlags & 8u) != 0)
{
if (!burnEffectController)
{
modelLocator = (modelLocator ? modelLocator : victimObject.GetComponent<ModelLocator>());
if ((bool)modelLocator && (bool)modelLocator.modelTransform)
{
burnEffectController = base.gameObject.AddComponent<BurnEffectController>();
burnEffectController.effectType = BurnEffectController.normalEffect;
burnEffectController.target = modelLocator.modelTransform.gameObject;
}
}
}
else if ((bool)burnEffectController)
{
burnEffectController.HandleDestroy();
burnEffectController = null;
}
if ((activeDotFlags & 0x80u) != 0)
{
if (!strongerBurnEffectController)
{
modelLocator = (modelLocator ? modelLocator : victimObject.GetComponent<ModelLocator>());
if ((bool)modelLocator && (bool)modelLocator.modelTransform)
{
strongerBurnEffectController = base.gameObject.AddComponent<BurnEffectController>();
strongerBurnEffectController.effectType = BurnEffectController.strongerBurnEffect;
strongerBurnEffectController.target = modelLocator.modelTransform.gameObject;
}
}
}
else if ((bool)strongerBurnEffectController)
{
strongerBurnEffectController.HandleDestroy();
strongerBurnEffectController = null;
}
if ((activeDotFlags & 4u) != 0)
{
if (!helfireEffectController)
{
modelLocator = (modelLocator ? modelLocator : victimObject.GetComponent<ModelLocator>());
if ((bool)modelLocator && (bool)modelLocator.modelTransform)
{
helfireEffectController = base.gameObject.AddComponent<BurnEffectController>();
helfireEffectController.effectType = BurnEffectController.helfireEffect;
helfireEffectController.target = modelLocator.modelTransform.gameObject;
}
}
}
else if ((bool)helfireEffectController)
{
helfireEffectController.HandleDestroy();
helfireEffectController = null;
}
if ((activeDotFlags & 0x10u) != 0)
{
if (!poisonEffectController)
{
modelLocator = (modelLocator ? modelLocator : victimObject.GetComponent<ModelLocator>());
if ((bool)modelLocator && (bool)modelLocator.modelTransform)
{
poisonEffectController = base.gameObject.AddComponent<BurnEffectController>();
poisonEffectController.effectType = BurnEffectController.poisonEffect;
poisonEffectController.target = modelLocator.modelTransform.gameObject;
}
}
}
else if ((bool)poisonEffectController)
{
poisonEffectController.HandleDestroy();
poisonEffectController = null;
}
if ((activeDotFlags & 0x20u) != 0)
{
if (!blightEffectController)
{
modelLocator = (modelLocator ? modelLocator : victimObject.GetComponent<ModelLocator>());
if ((bool)modelLocator && (bool)modelLocator.modelTransform)
{
blightEffectController = base.gameObject.AddComponent<BurnEffectController>();
blightEffectController.effectType = BurnEffectController.blightEffect;
blightEffectController.target = modelLocator.modelTransform.gameObject;
}
}
}
else if ((bool)blightEffectController)
{
blightEffectController.HandleDestroy();
blightEffectController = null;
}
if ((activeDotFlags & 0x40u) != 0)
{
if (!superBleedEffect)
{
superBleedEffect = GetPooledEffect("Prefabs/SuperBleedEffect");
}
}
else if ((bool)superBleedEffect)
{
RepoolEffect(ref superBleedEffect);
}
if ((activeDotFlags & 0x100u) != 0)
{
if (!preFractureEffect)
{
preFractureEffect = GetPooledEffect("Prefabs/PreFractureEffect");
}
}
else if ((bool)preFractureEffect)
{
RepoolEffect(ref preFractureEffect);
}
}
private void LateUpdate()
{
if ((bool)victimObject)
{
base.transform.position = victimObject.transform.position;
}
}
private static void AddPendingDamageEntry(List<PendingDamage> pendingDamages, GameObject attackerObject, float damage, DamageTypeCombo damageType)
{
for (int i = 0; i < pendingDamages.Count; i++)
{
if (pendingDamages[i].attackerObject == attackerObject)
{
pendingDamages[i].totalDamage += damage;
return;
}
}
PendingDamage pendingDamage = pendingDamagePool.Request();
pendingDamage.attackerObject = attackerObject;
pendingDamage.totalDamage = damage;
pendingDamage.damageType = damageType;
pendingDamages.Add(pendingDamage);
}
private void OnDotStackAddedServer(DotStack dotStack)
{
DotDef dotDef = dotStack.dotDef;
if (dotDef.associatedBuff != null && (bool)victimBody)
{
victimBody.AddBuff(dotDef.associatedBuff.buffIndex);
}
}
private void OnDotStackRemovedServer(DotStack dotStack)
{
DotDef dotDef = dotStack.dotDef;
if ((bool)victimBody)
{
if (dotDef.associatedBuff != null)
{
victimBody.RemoveBuff(dotDef.associatedBuff.buffIndex);
}
if (dotDef.terminalTimedBuff != null)
{
victimBody.AddTimedBuff(dotDef.terminalTimedBuff, dotDef.terminalTimedBuffDuration);
}
}
}
private void RemoveDotStackAtServer(int i)
{
DotStack dotStack = dotStackList[i];
dotStackList.RemoveAt(i);
OnDotStackRemovedServer(dotStack);
dotStackPool.Return(dotStack);
}
private void EvaluateDotStacksForType(DotIndex dotIndex, float dt, out int remainingActive)
{
List<PendingDamage> list = CollectionPool<PendingDamage, List<PendingDamage>>.RentCollection();
remainingActive = 0;
DotDef dotDef = GetDotDef(dotIndex);
for (int num = dotStackList.Count - 1; num >= 0; num--)
{
DotStack dotStack = dotStackList[num];
if (dotStack.dotIndex == dotIndex)
{
dotStack.timer -= dt;
AddPendingDamageEntry(list, dotStack.attackerObject, dotStack.damage, dotStack.damageType);
if (dotStack.timer <= 0f)
{
RemoveDotStackAtServer(num);
}
else
{
remainingActive++;
}
}
}
if ((bool)victimObject)
{
if ((bool)victimBody && dotIndex == DotIndex.Fracture && list.Count > 0)
{
if (FractureImpactEffectPrefab == null)
{
FractureImpactEffectPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/FractureImpactEffect");
}
EffectManager.SpawnEffect(FractureImpactEffectPrefab, new EffectData
{
origin = victimBody.corePosition
}, transmit: true);
}
if ((bool)victimHealthComponent)
{
Vector3 corePosition = victimBody.corePosition;
for (int i = 0; i < list.Count; i++)
{
DamageInfo damageInfo = new DamageInfo();
damageInfo.attacker = list[i].attackerObject;
damageInfo.crit = false;
damageInfo.damage = list[i].totalDamage;
damageInfo.force = Vector3.zero;
damageInfo.inflictor = base.gameObject;
damageInfo.position = corePosition;
damageInfo.procCoefficient = 0f;
damageInfo.damageColorIndex = dotDef.damageColorIndex;
damageInfo.damageType = list[i].damageType | DamageType.DoT;
damageInfo.dotIndex = dotIndex;
victimHealthComponent.TakeDamage(damageInfo);
}
}
}
for (int j = 0; j < list.Count; j++)
{
pendingDamagePool.Return(list[j]);
}
CollectionPool<PendingDamage, List<PendingDamage>>.ReturnCollection(list);
}
[Server]
private void AddDot(GameObject attackerObject, float duration, DotIndex dotIndex, float damageMultiplier, uint? maxStacksFromAttacker, float? totalDamage, DotIndex? preUpgradeDotIndex)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.DotController::AddDot(UnityEngine.GameObject,System.Single,RoR2.DotController/DotIndex,System.Single,System.Nullable`1<System.UInt32>,System.Nullable`1<System.Single>,System.Nullable`1<RoR2.DotController/DotIndex>)' called on client");
return;
}
TeamIndex attackerTeam = TeamIndex.Neutral;
float num = 0f;
TeamComponent component = attackerObject.GetComponent<TeamComponent>();
if ((bool)component)
{
attackerTeam = component.teamIndex;
}
CharacterBody component2 = attackerObject.GetComponent<CharacterBody>();
if ((bool)component2)
{
num = component2.damage;
}
DotDef dotDef = dotDefs[(int)dotIndex];
DotStack dotStack = dotStackPool.Request();
dotStack.dotIndex = dotIndex;
dotStack.dotDef = dotDef;
dotStack.attackerObject = attackerObject;
dotStack.attackerTeam = attackerTeam;
dotStack.timer = duration;
dotStack.damage = dotDef.damageCoefficient * num * damageMultiplier;
dotStack.damageType = DamageType.Generic;
int num2 = 0;
int i = 0;
for (int count = dotStackList.Count; i < count; i++)
{
if (dotStackList[i].dotIndex == dotIndex)
{
num2++;
}
}
switch (dotIndex)
{
case DotIndex.Bleed:
case DotIndex.SuperBleed:
case DotIndex.Fracture:
case DotIndex.LunarRuin:
{
int k = 0;
for (int count3 = dotStackList.Count; k < count3; k++)
{
if (dotStackList[k].dotIndex == dotIndex)
{
dotStackList[k].timer = Mathf.Max(dotStackList[k].timer, duration);
}
}
break;
}
case DotIndex.Burn:
case DotIndex.StrongerBurn:
dotStack.damage = Mathf.Min(dotStack.damage, victimBody.healthComponent.fullCombinedHealth * 0.01f * damageMultiplier);
break;
case DotIndex.PercentBurn:
dotStack.damage = Mathf.Min(dotStack.damage, victimBody.healthComponent.fullCombinedHealth * 0.01f);
break;
case DotIndex.Helfire:
{
if (!component2)
{
return;
}
HealthComponent healthComponent = component2.healthComponent;
if (!healthComponent)
{
return;
}
dotStack.damage = Mathf.Min(healthComponent.fullCombinedHealth * 0.01f * damageMultiplier, victimBody.healthComponent.fullCombinedHealth * 0.01f * damageMultiplier);
if ((bool)victimBody)
{
if (HelfireIgniteEffectPrefab == null)
{
HelfireIgniteEffectPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/HelfireIgniteEffect");
}
EffectManager.SpawnEffect(HelfireIgniteEffectPrefab, new EffectData
{
origin = victimBody.corePosition
}, transmit: true);
}
break;
}
case DotIndex.Poison:
{
float a = victimHealthComponent.fullCombinedHealth / 100f * 1f * dotDef.interval;
dotStack.damage = Mathf.Min(Mathf.Max(a, dotStack.damage), dotStack.damage * 50f);
dotStack.damageType = DamageType.NonLethal;
int j = 0;
for (int count2 = dotStackList.Count; j < count2; j++)
{
if (dotStackList[j].dotIndex == DotIndex.Poison)
{
dotStackList[j].timer = Mathf.Max(dotStackList[j].timer, duration);
dotStackList[j].damage = dotStack.damage;
return;
}
}
if (num2 == 0)
{
component2?.master?.playerStatsComponent?.currentStats.PushStatValue(StatDef.totalCrocoInfectionsInflicted, 1uL);
}
break;
}
}
if ((dotIndex == DotIndex.Helfire || (preUpgradeDotIndex.HasValue && preUpgradeDotIndex.Value == DotIndex.Helfire)) && victimObject == attackerObject)
{
dotStack.damageType |= (DamageTypeCombo)(DamageType.NonLethal | DamageType.Silent);
}
dotStack.damage = Mathf.Max(1f, dotStack.damage);
if (totalDamage.HasValue && dotStack.damage != 0f)
{
duration = totalDamage.Value * dotDef.interval / dotStack.damage;
dotStack.timer = duration;
}
if (maxStacksFromAttacker.HasValue)
{
DotStack dotStack2 = null;
int num3 = 0;
int l = 0;
for (int count4 = dotStackList.Count; l < count4; l++)
{
DotStack dotStack3 = dotStackList[l];
if (dotStack3.dotIndex == dotIndex && dotStack3.attackerObject == attackerObject)
{
num3++;
if (dotStack2 == null || dotStack3.timer < dotStack2.timer)
{
dotStack2 = dotStack3;
}
}
}
if (num3 >= maxStacksFromAttacker.Value && dotStack2 != null)
{
if (dotStack2.timer < duration)
{
dotStack2.timer = duration;
dotStack2.damage = dotStack.damage;
dotStack2.damageType = dotStack.damageType;
}
return;
}
}
if (num2 == 0 || dotDef.resetTimerOnAdd)
{
NetworkactiveDotFlags = activeDotFlags | (uint)(1 << (int)dotIndex);
dotTimers[(int)dotIndex] = dotDef.interval;
}
dotStackList.Add(dotStack);
OnDotStackAddedServer(dotStack);
}
[Server]
public static void InflictDot(ref InflictDotInfo inflictDotInfo)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.DotController::InflictDot(RoR2.InflictDotInfo&)' called on client");
}
else
{
if (inflictDotInfo.dotIndex < DotIndex.Bleed || inflictDotInfo.dotIndex >= DotIndex.Count || ImmuneToDebuffBehavior.OverrideDot(inflictDotInfo) || !inflictDotInfo.victimObject || !inflictDotInfo.attackerObject)
{
return;
}
if (!dotControllerLocator.TryGetValue(inflictDotInfo.victimObject.GetInstanceID(), out var value))
{
if (DotControllerPrefab == null)
{
DotControllerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/DotController");
}
GameObject obj = UnityEngine.Object.Instantiate(DotControllerPrefab);
value = obj.GetComponent<DotController>();
value.victimObject = inflictDotInfo.victimObject;
value.recordedVictimInstanceId = inflictDotInfo.victimObject.GetInstanceID();
dotControllerLocator.Add(value.recordedVictimInstanceId, value);
NetworkServer.Spawn(obj);
}
value.AddDot(inflictDotInfo.attackerObject, inflictDotInfo.duration, inflictDotInfo.dotIndex, inflictDotInfo.damageMultiplier, inflictDotInfo.maxStacksFromAttacker, inflictDotInfo.totalDamage, inflictDotInfo.preUpgradeDotIndex);
DotController.onDotInflictedServerGlobal?.Invoke(value, ref inflictDotInfo);
}
}
[Server]
public static void InflictDot(GameObject victimObject, GameObject attackerObject, DotIndex dotIndex, float duration = 8f, float damageMultiplier = 1f, uint? maxStacksFromAttacker = null)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.DotController::InflictDot(UnityEngine.GameObject,UnityEngine.GameObject,RoR2.DotController/DotIndex,System.Single,System.Single,System.Nullable`1<System.UInt32>)' called on client");
return;
}
InflictDotInfo inflictDotInfo = default(InflictDotInfo);
inflictDotInfo.victimObject = victimObject;
inflictDotInfo.attackerObject = attackerObject;
inflictDotInfo.dotIndex = dotIndex;
inflictDotInfo.duration = duration;
inflictDotInfo.damageMultiplier = damageMultiplier;
inflictDotInfo.maxStacksFromAttacker = maxStacksFromAttacker;
InflictDotInfo inflictDotInfo2 = inflictDotInfo;
InflictDot(ref inflictDotInfo2);
}
[Server]
public static void RemoveAllDots(GameObject victimObject)
{
DotController value;
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.DotController::RemoveAllDots(UnityEngine.GameObject)' called on client");
}
else if (dotControllerLocator.TryGetValue(victimObject.GetInstanceID(), out value))
{
value.HandleDestroy();
}
}
[Server]
public static DotController FindDotController(GameObject victimObject)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'RoR2.DotController RoR2.DotController::FindDotController(UnityEngine.GameObject)' called on client");
return null;
}
int i = 0;
for (int count = instancesList.Count; i < count; i++)
{
if ((object)victimObject == instancesList[i]._victimObject)
{
return instancesList[i];
}
}
return null;
}
private void UNetVersion()
{
}
public override bool OnSerialize(NetworkWriter writer, bool forceAll)
{
if (forceAll)
{
writer.Write(victimObjectId);
writer.WritePackedUInt32(activeDotFlags);
return true;
}
bool flag = false;
if ((base.syncVarDirtyBits & (true ? 1u : 0u)) != 0)
{
if (!flag)
{
writer.WritePackedUInt32(base.syncVarDirtyBits);
flag = true;
}
writer.Write(victimObjectId);
}
if ((base.syncVarDirtyBits & 2u) != 0)
{
if (!flag)
{
writer.WritePackedUInt32(base.syncVarDirtyBits);
flag = true;
}
writer.WritePackedUInt32(activeDotFlags);
}
if (!flag)
{
writer.WritePackedUInt32(base.syncVarDirtyBits);
}
return flag;
}
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
if (initialState)
{
victimObjectId = reader.ReadNetworkId();
activeDotFlags = reader.ReadPackedUInt32();
return;
}
int num = (int)reader.ReadPackedUInt32();
if (((uint)num & (true ? 1u : 0u)) != 0)
{
victimObjectId = reader.ReadNetworkId();
}
if (((uint)num & 2u) != 0)
{
activeDotFlags = reader.ReadPackedUInt32();
}
}
public override void PreStartClient()
{
}
}