r2mods/ilspy_dump/ror2_csproj/RoR2/CharacterBody.cs

5542 lines
156 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.Linq;
using System.Runtime.CompilerServices;
using EntityStates;
using EntityStates.Railgunner.Scope;
using HG;
using RoR2.Audio;
using RoR2.Items;
using RoR2.Navigation;
using RoR2.Networking;
using RoR2.PostProcessing;
using RoR2.Projectile;
using RoR2.Skills;
using Unity;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.Serialization;
namespace RoR2;
[DisallowMultipleComponent]
[RequireComponent(typeof(TeamComponent))]
[RequireComponent(typeof(SkillLocator))]
public class CharacterBody : NetworkBehaviour, ILifeBehavior, IDisplayNameProvider, IOnTakeDamageServerReceiver, IOnKilledOtherServerReceiver
{
public static class CommonAssets
{
public static SkillDef lunarUtilityReplacementSkillDef;
public static SkillDef lunarPrimaryReplacementSkillDef;
public static SkillDef lunarSecondaryReplacementSkillDef;
public static SkillDef lunarSpecialReplacementSkillDef;
public static NetworkSoundEventDef nullifiedBuffAppliedSound;
public static NetworkSoundEventDef pulverizeBuildupBuffAppliedSound;
public static NetworkSoundEventDef[] procCritAttackSpeedSounds;
public static GameObject thornExplosionEffect;
public static GameObject teleportOnLowHealthVFX;
public static GameObject teleportOnLowHealthExplosion;
public static GameObject teleportOnLowHealthExplosionNova;
public static GameObject prayerBeadEffect;
public static GameObject goldOnStageStartEffect;
public static void Load()
{
LegacyResourcesAPI.LoadAsyncCallback("NetworkSoundEventDefs/nseNullifiedBuffApplied", delegate(NetworkSoundEventDef asset)
{
nullifiedBuffAppliedSound = asset;
});
LegacyResourcesAPI.LoadAsyncCallback("NetworkSoundEventDefs/nsePulverizeBuildupBuffApplied", delegate(NetworkSoundEventDef asset)
{
pulverizeBuildupBuffAppliedSound = asset;
});
procCritAttackSpeedSounds = new NetworkSoundEventDef[3];
LegacyResourcesAPI.LoadAsyncCallback("NetworkSoundEventDefs/nseProcCritAttackSpeed1", delegate(NetworkSoundEventDef asset)
{
procCritAttackSpeedSounds[0] = asset;
});
LegacyResourcesAPI.LoadAsyncCallback("NetworkSoundEventDefs/nseProcCritAttackSpeed2", delegate(NetworkSoundEventDef asset)
{
procCritAttackSpeedSounds[1] = asset;
});
LegacyResourcesAPI.LoadAsyncCallback("NetworkSoundEventDefs/nseProcCritAttackSpeed3", delegate(NetworkSoundEventDef asset)
{
procCritAttackSpeedSounds[2] = asset;
});
AsyncOperationHandle<GameObject> asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/Effects/NoxiousThornExplosion");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
thornExplosionEffect = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/Effects/TeleportOnLowHealthVFX");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
teleportOnLowHealthVFX = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/Effects/TeleportOnLowHealthExplosion");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
teleportOnLowHealthExplosion = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/Effects/VagrantNovaExplosion");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
teleportOnLowHealthExplosionNova = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/Effects/ExtraStatsOnLevelUpScrapEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
prayerBeadEffect = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/Effects/GoldOnStageStartCoinGain");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
goldOnStageStartEffect = x.Result;
};
SkillCatalog.skillsDefined.CallWhenAvailable(delegate
{
lunarUtilityReplacementSkillDef = SkillCatalog.GetSkillDef(SkillCatalog.FindSkillIndexByName("LunarUtilityReplacement"));
lunarPrimaryReplacementSkillDef = SkillCatalog.GetSkillDef(SkillCatalog.FindSkillIndexByName("LunarPrimaryReplacement"));
lunarSecondaryReplacementSkillDef = SkillCatalog.GetSkillDef(SkillCatalog.FindSkillIndexByName("LunarSecondaryReplacement"));
lunarSpecialReplacementSkillDef = SkillCatalog.GetSkillDef(SkillCatalog.FindSkillIndexByName("LunarDetonatorSpecialReplacement"));
});
}
}
private class TimedBuff
{
public BuffIndex buffIndex;
public float timer;
}
public delegate void JumpDelegate();
[Flags]
public enum BodyFlags : uint
{
None = 0u,
IgnoreFallDamage = 1u,
Mechanical = 2u,
Masterless = 4u,
ImmuneToGoo = 8u,
ImmuneToExecutes = 0x10u,
SprintAnyDirection = 0x20u,
ResistantToAOE = 0x40u,
HasBackstabPassive = 0x80u,
HasBackstabImmunity = 0x100u,
OverheatImmune = 0x200u,
Void = 0x400u,
ImmuneToVoidDeath = 0x800u,
IgnoreItemUpdates = 0x1000u,
Devotion = 0x2000u,
IgnoreKnockback = 0x4000u,
ImmuneToLava = 0x8000u
}
private struct ItemAvailability
{
public int helfireCount;
public bool hasFireTrail;
public bool hasAffixLunar;
public bool hasAffixPoison;
}
[Serializable]
public struct NetworkItemBehaviorData
{
public int intItemValue;
public float floatValue;
public ItemIndex itemIndex
{
get
{
return (ItemIndex)intItemValue;
}
set
{
intItemValue = (int)value;
}
}
public NetworkItemBehaviorData(ItemIndex _index, float _floatValue)
{
intItemValue = (int)_index;
floatValue = _floatValue;
}
public NetworkItemBehaviorData(int _index, float _floatVal)
{
intItemValue = _index;
floatValue = _floatVal;
}
}
public class ItemBehavior : MonoBehaviour
{
public CharacterBody body;
public int stack;
}
public class AffixHauntedBehavior : ItemBehavior
{
private GameObject affixHauntedWard;
private void FixedUpdate()
{
if (!NetworkServer.active)
{
return;
}
bool flag = stack > 0;
if ((bool)affixHauntedWard != flag)
{
if (flag)
{
affixHauntedWard = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/AffixHauntedWard"));
affixHauntedWard.GetComponent<TeamFilter>().teamIndex = body.teamComponent.teamIndex;
affixHauntedWard.GetComponent<BuffWard>().Networkradius = 30f + body.radius;
affixHauntedWard.GetComponent<NetworkedBodyAttachment>().AttachToGameObjectAndSpawn(body.gameObject);
}
else
{
UnityEngine.Object.Destroy(affixHauntedWard);
affixHauntedWard = null;
}
}
}
private void OnDisable()
{
if ((bool)affixHauntedWard)
{
UnityEngine.Object.Destroy(affixHauntedWard);
}
}
}
public class QuestVolatileBatteryBehaviorServer : ItemBehavior
{
private NetworkedBodyAttachment attachment;
private void Start()
{
attachment = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/QuestVolatileBatteryAttachment")).GetComponent<NetworkedBodyAttachment>();
attachment.AttachToGameObjectAndSpawn(body.gameObject);
}
private void OnDestroy()
{
if ((bool)attachment)
{
UnityEngine.Object.Destroy(attachment.gameObject);
attachment = null;
}
}
}
public class TimeBubbleItemBehaviorServer : ItemBehavior
{
private void OnDestroy()
{
if ((bool)body.timeBubbleWardInstance)
{
UnityEngine.Object.Destroy(body.timeBubbleWardInstance);
}
}
}
public class ElementalRingsBehavior : ItemBehavior
{
private void OnDisable()
{
if ((bool)body)
{
if (body.HasBuff(RoR2Content.Buffs.ElementalRingsReady))
{
body.RemoveBuff(RoR2Content.Buffs.ElementalRingsReady);
}
if (body.HasBuff(RoR2Content.Buffs.ElementalRingsCooldown))
{
body.RemoveBuff(RoR2Content.Buffs.ElementalRingsCooldown);
}
}
}
private void FixedUpdate()
{
bool flag = body.HasBuff(RoR2Content.Buffs.ElementalRingsCooldown);
bool flag2 = body.HasBuff(RoR2Content.Buffs.ElementalRingsReady);
if (!flag && !flag2)
{
body.AddBuff(RoR2Content.Buffs.ElementalRingsReady);
}
if (flag2 && flag)
{
body.RemoveBuff(RoR2Content.Buffs.ElementalRingsReady);
}
}
}
public class AffixEchoBehavior : ItemBehavior
{
private DeployableMinionSpawner echoSpawner1;
private DeployableMinionSpawner echoSpawner2;
private CharacterSpawnCard spawnCard;
private List<CharacterMaster> spawnedEchoes = new List<CharacterMaster>();
private void FixedUpdate()
{
spawnCard.nodeGraphType = (body.isFlying ? MapNodeGroup.GraphType.Air : MapNodeGroup.GraphType.Ground);
}
private void Awake()
{
base.enabled = false;
}
private void OnEnable()
{
MasterCatalog.MasterIndex masterIndex = MasterCatalog.FindAiMasterIndexForBody(body.bodyIndex);
spawnCard = ScriptableObject.CreateInstance<CharacterSpawnCard>();
spawnCard.prefab = MasterCatalog.GetMasterPrefab(masterIndex);
spawnCard.inventoryToCopy = body.inventory;
spawnCard.equipmentToGrant = new EquipmentDef[1];
spawnCard.itemsToGrant = new ItemCountPair[1]
{
new ItemCountPair
{
itemDef = RoR2Content.Items.SummonedEcho,
count = 1
}
};
CreateSpawners();
}
private void OnDisable()
{
UnityEngine.Object.Destroy(spawnCard);
spawnCard = null;
for (int num = spawnedEchoes.Count - 1; num >= 0; num--)
{
if ((bool)spawnedEchoes[num])
{
spawnedEchoes[num].TrueKill();
}
}
DestroySpawners();
}
private void CreateSpawners()
{
Xoroshiro128Plus rng = new Xoroshiro128Plus(Run.instance.seed ^ (ulong)GetInstanceID());
CreateSpawner(ref echoSpawner1, DeployableSlot.RoboBallRedBuddy, spawnCard);
CreateSpawner(ref echoSpawner2, DeployableSlot.RoboBallGreenBuddy, spawnCard);
void CreateSpawner(ref DeployableMinionSpawner buddySpawner, DeployableSlot deployableSlot, SpawnCard spawnCard)
{
buddySpawner = new DeployableMinionSpawner(body.master, deployableSlot, rng)
{
respawnInterval = 30f,
spawnCard = spawnCard
};
buddySpawner.onMinionSpawnedServer += OnMinionSpawnedServer;
}
}
private void DestroySpawners()
{
echoSpawner1?.Dispose();
echoSpawner1 = null;
echoSpawner2?.Dispose();
echoSpawner2 = null;
}
private void OnMinionSpawnedServer(SpawnCard.SpawnResult spawnResult)
{
GameObject spawnedInstance = spawnResult.spawnedInstance;
if (!spawnedInstance)
{
return;
}
CharacterMaster spawnedMaster = spawnedInstance.GetComponent<CharacterMaster>();
if ((bool)spawnedMaster)
{
spawnedEchoes.Add(spawnedMaster);
OnDestroyCallback.AddCallback(spawnedMaster.gameObject, delegate
{
spawnedEchoes.Remove(spawnedMaster);
});
}
}
}
private static class AssetReferences
{
public static GameObject engiShieldTempEffectPrefab;
public static GameObject bucklerShieldTempEffectPrefab;
public static GameObject slowDownTimeTempEffectPrefab;
public static GameObject crippleEffectPrefab;
public static GameObject tonicBuffEffectPrefab;
public static GameObject weakTempEffectPrefab;
public static GameObject energizedTempEffectPrefab;
public static GameObject barrierTempEffectPrefab;
public static GameObject nullifyStack1EffectPrefab;
public static GameObject nullifyStack2EffectPrefab;
public static GameObject nullifyStack3EffectPrefab;
public static GameObject regenBoostEffectPrefab;
public static GameObject elephantDefenseEffectPrefab;
public static GameObject healingDisabledEffectPrefab;
public static GameObject noCooldownEffectPrefab;
public static GameObject doppelgangerEffectPrefab;
public static GameObject deathmarkEffectPrefab;
public static GameObject crocoRegenEffectPrefab;
public static GameObject mercExposeEffectPrefab;
public static GameObject lifestealOnHitEffectPrefab;
public static GameObject teamWarCryEffectPrefab;
public static GameObject randomDamageEffectPrefab;
public static GameObject lunarGolemShieldEffectPrefab;
public static GameObject warbannerEffectPrefab;
public static GameObject teslaFieldEffectPrefab;
public static GameObject lunarSecondaryRootEffectPrefab;
public static GameObject lunarDetonatorEffectPrefab;
public static GameObject fruitingEffectPrefab;
public static GameObject mushroomVoidTempEffectPrefab;
public static GameObject bearVoidTempEffectPrefab;
public static GameObject outOfCombatArmorEffectPrefab;
public static GameObject voidFogMildEffectPrefab;
public static GameObject voidFogStrongEffectPrefab;
public static GameObject voidJailerSlowEffectPrefab;
public static GameObject voidRaidcrabWardWipeFogEffectPrefab;
public static GameObject aurelioniteBlessingEffectInstance;
public static GameObject permanentDebuffEffectPrefab;
public static void Resolve()
{
AsyncOperationHandle<GameObject> asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/EngiShield");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
engiShieldTempEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/BucklerDefense");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
bucklerShieldTempEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/SlowDownTime");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
slowDownTimeTempEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/CrippleEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
crippleEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/TonicBuffEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
tonicBuffEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/WeakEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
weakTempEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/EnergizedEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
energizedTempEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/BarrierEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
barrierTempEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/RegenBoostEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
regenBoostEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/ElephantDefense");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
elephantDefenseEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/HealingDisabledEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
healingDisabledEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/NoCooldownEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
noCooldownEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/DoppelgangerEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
doppelgangerEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/NullifyStack1Effect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
nullifyStack1EffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/NullifyStack2Effect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
nullifyStack2EffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/NullifyStack3Effect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
nullifyStack3EffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/DeathMarkEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
deathmarkEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/CrocoRegenEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
crocoRegenEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/MercExposeEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
mercExposeEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/LifeStealOnHitAura");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
lifestealOnHitEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/TeamWarCryAura");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
teamWarCryEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/LunarDefense");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
lunarGolemShieldEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/RandomDamageBuffEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
randomDamageEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/WarbannerBuffEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
warbannerEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/TeslaFieldBuffEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
teslaFieldEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/LunarSecondaryRootEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
lunarSecondaryRootEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/LunarDetonatorEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
lunarDetonatorEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/FruitingEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
fruitingEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/MushroomVoidEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
mushroomVoidTempEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/BearVoidEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
bearVoidTempEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/VoidFogMildEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
voidFogMildEffectPrefab = x.Result;
};
asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("Prefabs/TemporaryVisualEffects/VoidFogStrongEffect");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
voidFogStrongEffectPrefab = x.Result;
};
asyncOperationHandle = Addressables.LoadAssetAsync<GameObject>("RoR2/DLC1/VoidRaidCrab/VoidRaidCrabWardWipeFogEffect.prefab");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
voidRaidcrabWardWipeFogEffectPrefab = x.Result;
};
asyncOperationHandle = Addressables.LoadAssetAsync<GameObject>("RoR2/DLC1/OutOfCombatArmor/OutOfCombatArmorEffect.prefab");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
outOfCombatArmorEffectPrefab = x.Result;
};
asyncOperationHandle = Addressables.LoadAssetAsync<GameObject>("RoR2/DLC1/VoidJailer/VoidJailerTetherDebuff.prefab");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
voidJailerSlowEffectPrefab = x.Result;
};
asyncOperationHandle = Addressables.LoadAssetAsync<GameObject>("RoR2/DLC2/Elites/EliteAurelionite/AffixAurelioniteArmorBubble.prefab");
asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> x)
{
aurelioniteBlessingEffectInstance = x.Result;
};
}
}
private class ConstructTurretMessage : MessageBase
{
public GameObject builder;
public Vector3 position;
public Quaternion rotation;
public MasterCatalog.NetworkMasterIndex turretMasterIndex;
public override void Serialize(NetworkWriter writer)
{
writer.Write(builder);
writer.Write(position);
writer.Write(rotation);
GeneratedNetworkCode._WriteNetworkMasterIndex_MasterCatalog(writer, turretMasterIndex);
}
public override void Deserialize(NetworkReader reader)
{
builder = reader.ReadGameObject();
position = reader.ReadVector3();
rotation = reader.ReadQuaternion();
turretMasterIndex = GeneratedNetworkCode._ReadNetworkMasterIndex_MasterCatalog(reader);
}
}
private class DelayedDamageInfo
{
public DamageInfo halfDamage = new DamageInfo();
public float timeUntilDamage = 3f;
}
public class TeleportOnLowHealthBehavior : ItemBehavior
{
private CharacterBody characterBody;
private bool hasActivated;
private bool hasItem;
private bool hasBuff;
private bool hasCooldown;
private void Start()
{
if (!hasActivated)
{
characterBody = GetComponent<CharacterBody>();
characterBody.RemoveBuff(DLC2Content.Buffs.TeleportOnLowHealth);
characterBody.RemoveOldestTimedBuff(DLC2Content.Buffs.TeleportOnLowHealthCooldown);
characterBody.RemoveBuff(DLC2Content.Buffs.TeleportOnLowHealthCooldown);
characterBody.AddBuff(DLC2Content.Buffs.TeleportOnLowHealth);
characterBody.hasTeleported = false;
hasActivated = true;
}
}
private void Update()
{
hasItem = characterBody.inventory.GetItemCount(DLC2Content.Items.TeleportOnLowHealth) > 0;
hasBuff = characterBody.HasBuff(DLC2Content.Buffs.TeleportOnLowHealth);
hasCooldown = characterBody.HasBuff(DLC2Content.Buffs.TeleportOnLowHealthCooldown);
if (!hasItem)
{
if (hasBuff)
{
characterBody.RemoveBuff(DLC2Content.Buffs.TeleportOnLowHealth);
}
if (hasCooldown)
{
characterBody.RemoveBuff(DLC2Content.Buffs.TeleportOnLowHealthCooldown);
}
}
else if (!hasBuff && !hasCooldown && characterBody.hasTeleported)
{
characterBody.AddBuff(DLC2Content.Buffs.TeleportOnLowHealth);
characterBody.hasTeleported = false;
}
}
private void OnDisable()
{
characterBody.RemoveBuff(DLC2Content.Buffs.TeleportOnLowHealth);
characterBody.RemoveOldestTimedBuff(DLC2Content.Buffs.TeleportOnLowHealthCooldown);
characterBody.RemoveBuff(DLC2Content.Buffs.TeleportOnLowHealthCooldown);
}
}
public class DelayedDamageBehavior : ItemBehavior
{
private CharacterBody characterBody;
private bool hasActivated;
private bool hasItem;
private bool hasBuff;
private bool hasCooldown;
private void Start()
{
if (!hasActivated)
{
characterBody = GetComponent<CharacterBody>();
hasActivated = true;
}
}
private void Update()
{
hasItem = characterBody.inventory.GetItemCount(DLC2Content.Items.DelayedDamage) > 0;
hasBuff = characterBody.HasBuff(DLC2Content.Buffs.DelayedDamageBuff);
hasCooldown = characterBody.HasBuff(DLC2Content.Buffs.DelayedDamageBuff);
if (!hasItem)
{
if (hasBuff)
{
characterBody.RemoveBuff(DLC2Content.Buffs.DelayedDamageBuff);
characterBody.RemoveOldestTimedBuff(DLC2Content.Buffs.DelayedDamageBuff);
}
if (hasCooldown)
{
characterBody.RemoveBuff(DLC2Content.Buffs.DelayedDamageBuff);
characterBody.RemoveOldestTimedBuff(DLC2Content.Buffs.DelayedDamageBuff);
characterBody.RemoveBuff(DLC2Content.Buffs.DelayedDamageDebuff);
}
}
}
}
public class MeteorAttackOnHighDamageBehavior : ItemBehavior
{
private CharacterBody characterBody;
private bool hasActivated;
private void FixedUpdate()
{
if (!hasActivated)
{
characterBody = GetComponent<CharacterBody>();
hasActivated = true;
}
if (characterBody.runicLensMeteorReady)
{
characterBody.runicLensStartTime = Run.instance.time;
if (characterBody.runicLensStartTime >= characterBody.runicLensImpactTime && characterBody.runicLensMeteorReady)
{
characterBody.detonateRunicLensMeteor();
characterBody.runicLensMeteorReady = false;
}
}
}
}
[Serializable]
public class CharacterBodyUnityEvent : UnityEvent<CharacterBody>
{
}
[HideInInspector]
[Tooltip("This is assigned to the prefab automatically by BodyCatalog at runtime. Do not set this value manually.")]
public BodyIndex bodyIndex = BodyIndex.None;
public bool CharacterIsVisible;
[Tooltip("How much the combat director paid for this character. If this enemy is culled, then we refund the combat director for the cost it paid to spawn us.")]
public float cost = -1f;
public bool dontCull;
[Tooltip("The baseline importance for this character. 0 is standard, elites get a +2 modifier, bosses get +10, players get +5000. Characters of low importance are culled in some circumstances.")]
public int BaseImportance;
[Tooltip("The dynamically calculated level of importance for this enemy.")]
public int Importance = -1;
public bool inLava;
[Tooltip("The language token to use as the base name of this character.")]
public string baseNameToken;
public string subtitleNameToken;
private BuffIndex[] activeBuffsList;
private int activeBuffsListCount;
private int[] buffs;
private int eliteBuffCount;
private List<TimedBuff> timedBuffs = new List<TimedBuff>();
[NonSerialized]
public int pendingTonicAfflictionCount;
public JumpDelegate onJump;
private int previousMultiKillBuffCount;
private GameObject warCryEffectInstance;
[EnumMask(typeof(BodyFlags))]
public BodyFlags bodyFlags;
private NetworkInstanceId masterObjectId;
private GameObject _masterObject;
private CharacterMaster _master;
private bool linkedToMaster;
private bool disablingHurtBoxes;
private EquipmentIndex previousEquipmentIndex = EquipmentIndex.None;
private new Transform transform;
private SfxLocator sfxLocator;
public float lavaCooldown = 0.2f;
private float lavaTimer;
private ItemAvailability itemAvailability;
private static List<CharacterBody> instancesList;
public static readonly ReadOnlyCollection<CharacterBody> readOnlyInstancesList;
private bool _isSprinting;
private const float outOfCombatDelay = 5f;
private const float outOfDangerDelay = 7f;
private float outOfCombatStopwatch;
private float outOfDangerStopwatch;
private bool _outOfDanger = true;
private Vector3 previousPosition;
private const float notMovingWait = 1f;
private float notMovingStopwatch;
public bool rootMotionInMainState;
public float mainRootSpeed;
public float baseMaxHealth;
public float baseRegen;
public float baseMaxShield;
public float baseMoveSpeed;
public float baseAcceleration;
public float baseJumpPower;
public float baseDamage;
public float baseAttackSpeed;
public float baseCrit;
public float baseArmor;
public float baseVisionDistance = float.PositiveInfinity;
public int baseJumpCount = 1;
public float sprintingSpeedMultiplier = 1.45f;
public bool autoCalculateLevelStats;
public float levelMaxHealth;
public float levelRegen;
public float levelMaxShield;
public float levelMoveSpeed;
public float levelJumpPower;
public float levelDamage;
public float levelAttackSpeed;
public float levelCrit;
public float levelArmor;
private float m_surfaceSpeedBoost;
private bool statsDirty;
private int currentHealthLevel;
private int oldHealthLevel;
private float damageFromRecalculateStats;
private int numberOfKills;
private bool canCleanInventory = true;
public int extraSecondaryFromSkill;
public int extraSpecialFromSkill;
private GameObject lowerHealthHigherDamageSteam;
[HideInInspector]
public LowerHealthHigherDamageEffectUpdater lowerHealthHigherDamageEffectUpdater;
private bool boostAllStatsTimerStarted;
private bool boostAllStatsCoolDownTimerStarted;
private float boostAllStatsTimer;
private float boostAllStatsTriggerTimer = 5f;
private float boostAllStatsCoolDownTriggerTimer = 10f;
private float boostAllStatsCoolDownStartTimer;
private float boostAllStatsCoolDownTimer;
private float boostAllStatsStartTimer;
private float boostAllStatsTriggerChance;
public bool canBoostAllStats;
private float boostAllStatsDefaultTriggerChance = 0.25f;
private float boostAllStatsTriggerIncrease = 0.1f;
private float boostAllStatsMultiplier = 0.2f;
private int extraStatsOnLevelUpCountModifier;
[HideInInspector]
public IncreaseDamageOnMultiKillItemDisplayUpdater increaseDamageOnMultiKillItemDisplayUpdater;
private bool lowerPricedChestsActive;
private bool canPurchaseLoweredPricedChests;
public bool allSkillsDisabled;
private ScreenDamageCalculatorDisabledSkills screenDamageSkillsDisabled;
private int oldComboMeter;
public bool isTeleporting;
public int solitudeLevelCount;
private float aimTimer;
private const uint masterDirtyBit = 1u;
private const uint buffsDirtyBit = 2u;
private const uint outOfCombatBit = 4u;
private const uint outOfDangerBit = 8u;
private const uint sprintingBit = 16u;
private const uint allDirtyBits = 31u;
public Action<NetworkItemBehaviorData> OnNetworkItemBehaviorUpdate;
private HelfireController helfireController;
private float helfireLifetime;
private DamageTrail fireTrail;
public bool wasLucky;
private const float poisonballAngle = 25f;
private const float poisonballDamageCoefficient = 1f;
private const float poisonballRefreshTime = 6f;
private float poisonballTimer;
private const float lunarMissileDamageCoefficient = 0.3f;
private const float lunarMissileRefreshTime = 10f;
private const float lunarMissileDelayBetweenShots = 0.1f;
private float lunarMissileRechargeTimer = 10f;
private float lunarMissileTimerBetweenShots;
private int remainingMissilesToFire;
private GameObject lunarMissilePrefab;
private GameObject timeBubbleWardInstance;
private TemporaryVisualEffect engiShieldTempEffectInstance;
private TemporaryVisualEffect bucklerShieldTempEffectInstance;
private TemporaryVisualEffect slowDownTimeTempEffectInstance;
private TemporaryVisualEffect crippleEffectInstance;
private TemporaryVisualEffect tonicBuffEffectInstance;
private TemporaryVisualEffect weakTempEffectInstance;
private TemporaryVisualEffect energizedTempEffectInstance;
private TemporaryVisualEffect barrierTempEffectInstance;
private TemporaryVisualEffect nullifyStack1EffectInstance;
private TemporaryVisualEffect nullifyStack2EffectInstance;
private TemporaryVisualEffect nullifyStack3EffectInstance;
private TemporaryVisualEffect regenBoostEffectInstance;
private TemporaryVisualEffect elephantDefenseEffectInstance;
private TemporaryVisualEffect healingDisabledEffectInstance;
private TemporaryVisualEffect noCooldownEffectInstance;
private TemporaryVisualEffect doppelgangerEffectInstance;
private TemporaryVisualEffect deathmarkEffectInstance;
private TemporaryVisualEffect crocoRegenEffectInstance;
private TemporaryVisualEffect mercExposeEffectInstance;
private TemporaryVisualEffect lifestealOnHitEffectInstance;
private TemporaryVisualEffect teamWarCryEffectInstance;
private TemporaryVisualEffect randomDamageEffectInstance;
private TemporaryVisualEffect lunarGolemShieldEffectInstance;
private TemporaryVisualEffect warbannerEffectInstance;
private TemporaryVisualEffect teslaFieldEffectInstance;
private TemporaryVisualEffect lunarSecondaryRootEffectInstance;
private TemporaryVisualEffect lunarDetonatorEffectInstance;
private TemporaryVisualEffect fruitingEffectInstance;
private TemporaryVisualEffect mushroomVoidTempEffectInstance;
private TemporaryVisualEffect bearVoidTempEffectInstance;
private TemporaryVisualEffect outOfCombatArmorEffectInstance;
private TemporaryVisualEffect voidFogMildEffectInstance;
private TemporaryVisualEffect voidFogStrongEffectInstance;
private TemporaryVisualEffect voidJailerSlowEffectInstance;
private TemporaryVisualEffect voidRaidcrabWardWipeFogEffectInstance;
private TemporaryVisualEffect aurelioniteBlessingEffectInstance;
[Tooltip("How long it takes for spread bloom to reset from full.")]
public float spreadBloomDecayTime = 0.45f;
[Tooltip("The spread bloom interpretation curve.")]
public AnimationCurve spreadBloomCurve;
private float spreadBloomInternal;
[FormerlySerializedAs("crosshairPrefab")]
[SerializeField]
[Tooltip("The crosshair prefab used for this body.")]
private GameObject _defaultCrosshairPrefab;
[HideInInspector]
public bool hideCrosshair;
private const float multiKillMaxInterval = 1f;
private float multiKillTimer;
private const int multiKillThresholdForWarcry = 4;
private const float increasedDamageMultiKillMaxInterval = 5f;
private float increasedDamageKillTimer;
private int oldKillcount;
private const int multiKillThresholdForIncreasedDamage = 5;
private int secondarySkillStacks;
[HideInInspector]
public IncreasePrimaryDamageEffectUpdater increasePrimaryDamageEffectUpdater;
private float delayedDamageRefreshTime = 10f;
private float secondHalfOfDamageTime = 3f;
private int oldDelayedDamageCount;
private bool halfDamageReady;
private float halfDamageTimer;
public bool protectFromOneShot;
private DamageInfo secondHalfOfDamage;
private List<DelayedDamageInfo> incomingDamageList = new List<DelayedDamageInfo>();
public bool hasTeleported;
private Vector3 runicLensPosition;
private EffectData runicLensEffectData = new EffectData();
private DamageInfo runicLensDamageInfo = new DamageInfo();
private float runicLensDamage;
private float runicLensBlastForce;
private float runicLensBlastRadius;
private float runicLensStartTime;
private float runicLensImpactTime;
public bool runicLensMeteorReady;
private bool hasStackableDebuff;
private bool tamperedHeartActive;
private float tamperedHeartRegenBonus;
private float tamperedHeartMSpeedBonus;
private float tamperedHeartDamageBonus;
private float tamperedHeartAttackSpeedBonus;
private float tamperedHeartArmorBonus;
[Tooltip("The child transform to be used as the aiming origin.")]
public Transform aimOriginTransform;
[Tooltip("The hull size to use when pathfinding for this object.")]
public HullClassification hullClassification;
[Tooltip("The icon displayed for ally healthbars")]
public Texture portraitIcon;
[Tooltip("The main color of the body. Currently only used in the logbook.")]
public Color bodyColor = Color.clear;
[Tooltip("By default, players and enemies are assigned to either PlayerBody or EnemyBody, based on team. But some enemies (Gups) want a specific layer - this will skip that assignment.")]
public bool doNotReassignToTeamBasedCollisionLayer;
[FormerlySerializedAs("isBoss")]
[Tooltip("Whether or not this is a boss for dropping items on death.")]
public bool isChampion;
public VehicleSeat currentVehicle;
[Tooltip("The pod prefab to use for handling this character's first-time spawn animation.")]
public GameObject preferredPodPrefab;
[Tooltip("The preferred state to use for handling the character's first-time spawn animation. Only used with no preferred pod prefab.")]
public SerializableEntityStateType preferredInitialStateType = new SerializableEntityStateType(typeof(Uninitialized));
public uint skinIndex;
public string customKillTotalStatName;
public Transform overrideCoreTransform;
private static int kCmdCmdAddTimedBuff;
private static int kCmdCmdSetInLava;
private static int kCmdCmdUpdateSprint;
private static int kCmdCmdOnSkillActivated;
private static int kCmdCmdTransmitItemBehavior;
private static int kRpcRpcTransmitItemBehavior;
private static int kCmdCmdSpawnDelayedDamageEffect;
private static int kRpcRpcTeleportCharacterToSafety;
private static int kRpcRpcBark;
private static int kCmdCmdRequestVehicleEjection;
private static int kRpcRpcUsePreferredInitialStateType;
public CharacterMaster master
{
get
{
if (!masterObject)
{
return null;
}
return _master;
}
}
public Inventory inventory { get; private set; }
public bool isPlayerControlled { get; private set; }
public float executeEliteHealthFraction { get; private set; }
public GameObject masterObject
{
get
{
if (!_masterObject)
{
if (NetworkServer.active)
{
_masterObject = NetworkServer.FindLocalObject(masterObjectId);
}
else if (NetworkClient.active)
{
_masterObject = ClientScene.FindLocalObject(masterObjectId);
}
_master = (_masterObject ? _masterObject.GetComponent<CharacterMaster>() : null);
if ((bool)_master)
{
PlayerCharacterMasterController component = _masterObject.GetComponent<PlayerCharacterMasterController>();
isPlayerControlled = component;
if ((bool)inventory)
{
inventory.onInventoryChanged -= OnInventoryChanged;
}
inventory = _master.inventory;
if ((bool)inventory)
{
inventory.onInventoryChanged += OnInventoryChanged;
OnInventoryChanged();
}
statsDirty = true;
}
}
return _masterObject;
}
set
{
masterObjectId = value.GetComponent<NetworkIdentity>().netId;
statsDirty = true;
}
}
public Rigidbody rigidbody { get; private set; }
public NetworkIdentity networkIdentity { get; private set; }
public CharacterMotor characterMotor { get; private set; }
public CharacterDirection characterDirection { get; private set; }
public TeamComponent teamComponent { get; private set; }
public HealthComponent healthComponent { get; private set; }
public EquipmentSlot equipmentSlot { get; private set; }
public InputBankTest inputBank { get; private set; }
public SkillLocator skillLocator { get; private set; }
public ModelLocator modelLocator { get; private set; }
public HurtBoxGroup hurtBoxGroup { get; private set; }
public HurtBox mainHurtBox { get; private set; }
public Transform coreTransform { get; private set; }
public bool hasEffectiveAuthority { get; private set; }
public bool isSprinting
{
get
{
return _isSprinting;
}
set
{
if (_isSprinting != value)
{
_isSprinting = value;
RecalculateStats();
if (value)
{
OnSprintStart();
}
else
{
OnSprintStop();
}
if (NetworkServer.active)
{
SetDirtyBit(16u);
}
else if (hasEffectiveAuthority)
{
CallCmdUpdateSprint(value);
}
}
}
}
public bool outOfCombat { get; private set; } = true;
public bool outOfDanger
{
get
{
return _outOfDanger;
}
private set
{
if (_outOfDanger != value)
{
_outOfDanger = value;
OnOutOfDangerChanged();
}
}
}
public float experience { get; private set; }
public float level { get; private set; }
public float maxHealth { get; private set; }
public float maxBarrier { get; private set; }
public float barrierDecayRate { get; private set; }
public float regen { get; private set; }
public float maxShield { get; private set; }
public float moveSpeed { get; private set; }
public float acceleration { get; private set; }
public float surfaceSpeedBoost
{
get
{
return m_surfaceSpeedBoost;
}
set
{
if (!Mathf.Approximately(m_surfaceSpeedBoost, value))
{
m_surfaceSpeedBoost = value;
RecalculateStats();
}
}
}
public float jumpPower { get; private set; }
public int maxJumpCount { get; private set; }
public float maxJumpHeight { get; private set; }
public float damage { get; private set; }
public float attackSpeed { get; private set; }
public float crit { get; private set; }
public float critMultiplier { get; private set; }
public float bleedChance { get; private set; }
public float armor { get; private set; }
public float visionDistance { get; private set; }
public float critHeal { get; private set; }
public float cursePenalty { get; private set; }
public bool hasOneShotProtection { get; private set; }
public bool isGlass { get; private set; }
public float oneShotProtectionFraction { get; private set; }
public bool canPerformBackstab { get; private set; }
public bool canReceiveBackstab { get; private set; }
public float maxBonusHealth { get; private set; }
public bool shouldAim
{
get
{
if (aimTimer > 0f)
{
return !isSprinting;
}
return false;
}
}
public int killCountServer { get; private set; }
public float bestFitRadius => Mathf.Max(radius, characterMotor ? characterMotor.capsuleHeight : 1f);
public float bestFitActualRadius => Mathf.Max(radius, characterMotor ? (characterMotor.capsuleHeight * 0.5f) : 1f);
public bool hasCloakBuff
{
get
{
if (!HasBuff(RoR2Content.Buffs.Cloak))
{
return HasBuff(RoR2Content.Buffs.AffixHauntedRecipient);
}
return true;
}
}
public float spreadBloomAngle => spreadBloomCurve.Evaluate(spreadBloomInternal);
public GameObject defaultCrosshairPrefab => _defaultCrosshairPrefab;
public int multiKillCount { get; private set; }
public int increasedDamageKillCount { get; private set; }
public int increasedDamageKillCountBuff { get; private set; }
public float luminousShotDamage { get; private set; }
public bool luminousShotReady { get; private set; }
public Vector3 corePosition
{
get
{
if (!coreTransform)
{
return transform.position;
}
return coreTransform.position;
}
}
public Vector3 footPosition
{
get
{
Vector3 position = transform.position;
if ((bool)characterMotor)
{
position.y -= characterMotor.capsuleHeight * 0.5f;
}
return position;
}
}
public float radius { get; private set; }
public Vector3 aimOrigin
{
get
{
if (!aimOriginTransform)
{
return corePosition;
}
return aimOriginTransform.position;
}
}
public bool isElite { get; private set; }
public bool isBoss
{
get
{
if ((bool)master)
{
return master.isBoss;
}
return false;
}
}
public bool isFlying
{
get
{
if ((bool)characterMotor)
{
return characterMotor.isFlying;
}
return true;
}
}
public Run.FixedTimeStamp localStartTime { get; private set; } = Run.FixedTimeStamp.positiveInfinity;
public bool isEquipmentActivationAllowed
{
get
{
if ((bool)currentVehicle)
{
return currentVehicle.isEquipmentActivationAllowed;
}
return true;
}
}
public event Action onInventoryChanged;
public event Action<GenericSkill> onSkillActivatedServer;
public event Action<GenericSkill> onSkillActivatedAuthority;
public static event Action<CharacterBody> onBodyAwakeGlobal;
public static event Action<CharacterBody> onBodyDestroyGlobal;
public static event Action<CharacterBody> onBodyStartGlobal;
public static event Action<CharacterBody> onBodyInventoryChangedGlobal;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public CharacterBody GetBody()
{
return this;
}
public void DebugDrawLine(Vector3 start, Vector3 end, Color color)
{
Debug.DrawLine(start, end, color, 5f);
}
[InitDuringStartup]
private static void LoadCommonAssets()
{
CommonAssets.Load();
}
public string GetDisplayName()
{
return Language.GetString(baseNameToken);
}
public string GetSubtitle()
{
return Language.GetString(subtitleNameToken);
}
public string GetUserName()
{
string text = "";
if ((bool)master)
{
PlayerCharacterMasterController component = master.GetComponent<PlayerCharacterMasterController>();
if ((bool)component)
{
text = component.GetDisplayName();
}
}
if (string.IsNullOrEmpty(text))
{
text = GetDisplayName();
}
return text;
}
public string GetColoredUserName()
{
Color32 color = new Color32(127, 127, 127, byte.MaxValue);
string text = null;
if ((bool)master)
{
PlayerCharacterMasterController component = master.GetComponent<PlayerCharacterMasterController>();
if ((bool)component)
{
GameObject networkUserObject = component.networkUserObject;
if ((bool)networkUserObject)
{
NetworkUser component2 = networkUserObject.GetComponent<NetworkUser>();
if ((bool)component2)
{
color = component2.userColor;
text = component2.userName;
}
}
}
}
if (text == null)
{
text = GetDisplayName();
}
return Util.GenerateColoredString(text, color);
}
[Server]
private void WriteBuffs(NetworkWriter writer)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::WriteBuffs(UnityEngine.Networking.NetworkWriter)' called on client");
return;
}
writer.Write((byte)activeBuffsListCount);
for (int i = 0; i < activeBuffsListCount; i++)
{
BuffIndex buffIndex = activeBuffsList[i];
BuffDef buffDef = BuffCatalog.GetBuffDef(buffIndex);
writer.WriteBuffIndex(buffIndex);
if (buffDef.canStack)
{
writer.WritePackedUInt32((uint)buffs[(int)buffIndex]);
}
}
}
[Client]
private void ReadBuffs(NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogWarning("[Client] function 'System.Void RoR2.CharacterBody::ReadBuffs(UnityEngine.Networking.NetworkReader)' called on server");
return;
}
if (activeBuffsList == null)
{
Debug.LogError("Trying to ReadBuffs, but our activeBuffsList is null");
return;
}
int activeBuffsIndexToCheck = 0;
int num = reader.ReadByte();
BuffIndex buffIndex = BuffIndex.None;
for (int i = 0; i < num; i++)
{
BuffIndex buffIndex2 = reader.ReadBuffIndex();
BuffDef buffDef = BuffCatalog.GetBuffDef(buffIndex2);
if (buffDef != null)
{
int num2 = 1;
if (buffDef.canStack)
{
num2 = (int)reader.ReadPackedUInt32();
}
if (num2 > 0 && !NetworkServer.active)
{
ZeroBuffIndexRange(buffIndex + 1, buffIndex2);
SetBuffCount(buffIndex2, num2);
}
buffIndex = buffIndex2;
}
else
{
Debug.LogErrorFormat("No BuffDef for index {0}. body={1}, netID={2}", buffIndex2, base.gameObject, base.netId);
}
}
if (!NetworkServer.active)
{
ZeroBuffIndexRange(buffIndex + 1, (BuffIndex)BuffCatalog.buffCount);
}
void ZeroBuffIndexRange(BuffIndex start, BuffIndex end)
{
while (activeBuffsIndexToCheck < activeBuffsListCount)
{
BuffIndex buffIndex3 = activeBuffsList[activeBuffsIndexToCheck];
if (end <= buffIndex3)
{
break;
}
int num3;
if (start <= buffIndex3)
{
SetBuffCount(buffIndex3, 0);
num3 = activeBuffsIndexToCheck - 1;
activeBuffsIndexToCheck = num3;
}
num3 = activeBuffsIndexToCheck + 1;
activeBuffsIndexToCheck = num3;
}
}
}
[Server]
public void AddBuff(BuffIndex buffType)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::AddBuff(RoR2.BuffIndex)' called on client");
}
else if (buffType != BuffIndex.None)
{
SetBuffCount(buffType, buffs[(int)buffType] + 1);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[Server]
public void AddBuff(BuffDef buffDef)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::AddBuff(RoR2.BuffDef)' called on client");
}
else
{
AddBuff(buffDef?.buffIndex ?? BuffIndex.None);
}
}
[Server]
public void RemoveBuff(BuffIndex buffType)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::RemoveBuff(RoR2.BuffIndex)' called on client");
}
else
{
if (buffType == BuffIndex.None)
{
return;
}
SetBuffCount(buffType, buffs[(int)buffType] - 1);
if (buffType == RoR2Content.Buffs.MedkitHeal.buffIndex)
{
if (GetBuffCount(RoR2Content.Buffs.MedkitHeal.buffIndex) == 0)
{
int itemCount = inventory.GetItemCount(RoR2Content.Items.Medkit);
float num = 20f;
float num2 = maxHealth * 0.05f * (float)itemCount;
healthComponent.Heal(num + num2, default(ProcChainMask));
EffectData effectData = new EffectData
{
origin = transform.position
};
effectData.SetNetworkedObjectReference(base.gameObject);
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/MedkitHealEffect"), effectData, transmit: true);
}
}
else if (buffType == RoR2Content.Buffs.TonicBuff.buffIndex)
{
if ((bool)inventory && GetBuffCount(RoR2Content.Buffs.TonicBuff) == 0 && pendingTonicAfflictionCount > 0)
{
inventory.GiveItem(RoR2Content.Items.TonicAffliction, pendingTonicAfflictionCount);
PickupIndex pickupIndex = PickupCatalog.FindPickupIndex(RoR2Content.Items.TonicAffliction.itemIndex);
GenericPickupController.SendPickupMessage(master, pickupIndex);
pendingTonicAfflictionCount = 0;
}
}
else if (buffType == DLC2Content.Buffs.SoulCost.buffIndex)
{
cursePenalty -= 0.1f * (float)GetBuffCount(DLC2Content.Buffs.SoulCost);
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[Server]
public void RemoveBuff(BuffDef buffDef)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::RemoveBuff(RoR2.BuffDef)' called on client");
}
else
{
RemoveBuff(buffDef?.buffIndex ?? BuffIndex.None);
}
}
public void SetBuffCount(BuffIndex buffType, int newCount)
{
newCount = Mathf.Max(newCount, 0);
ref int reference = ref buffs[(int)buffType];
if (newCount == reference)
{
return;
}
int num = reference;
reference = newCount;
BuffDef buffDef = BuffCatalog.GetBuffDef(buffType);
bool flag = true;
if (!buffDef.canStack)
{
flag = num == 0 != (newCount == 0);
}
if (flag)
{
if (newCount == 0)
{
ArrayUtils.ArrayRemoveAt(activeBuffsList, ref activeBuffsListCount, Array.IndexOf(activeBuffsList, buffType));
OnBuffFinalStackLost(buffDef);
}
else if (num == 0)
{
int i;
for (i = 0; i < activeBuffsListCount && buffType >= activeBuffsList[i]; i++)
{
}
ArrayUtils.ArrayInsert(ref activeBuffsList, ref activeBuffsListCount, i, in buffType);
OnBuffFirstStackGained(buffDef);
}
if (NetworkServer.active)
{
SetDirtyBit(2u);
}
}
statsDirty = true;
if (NetworkClient.active)
{
OnClientBuffsChanged();
}
UpdateItemAvailability();
}
private void OnBuffFirstStackGained(BuffDef buffDef)
{
if (buffDef.isElite)
{
eliteBuffCount++;
}
if (buffDef == RoR2Content.Buffs.Intangible)
{
UpdateHurtBoxesEnabled();
}
else if (buffDef == RoR2Content.Buffs.WarCryBuff)
{
if (HasBuff(RoR2Content.Buffs.TeamWarCry))
{
ClearTimedBuffs(RoR2Content.Buffs.TeamWarCry);
}
}
else if (buffDef == RoR2Content.Buffs.TeamWarCry)
{
if (HasBuff(RoR2Content.Buffs.WarCryBuff))
{
ClearTimedBuffs(RoR2Content.Buffs.WarCryBuff);
}
}
else if (buffDef == RoR2Content.Buffs.AffixEcho && NetworkServer.active)
{
AddItemBehavior<AffixEchoBehavior>(1);
}
}
private void OnBuffFinalStackLost(BuffDef buffDef)
{
if (buffDef.isElite)
{
eliteBuffCount--;
}
if (buffDef.buffIndex == RoR2Content.Buffs.Intangible.buffIndex)
{
UpdateHurtBoxesEnabled();
}
else if (buffDef == RoR2Content.Buffs.AffixEcho && NetworkServer.active)
{
AddItemBehavior<AffixEchoBehavior>(0);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int GetBuffCount(BuffIndex buffType)
{
return ArrayUtils.GetSafe(buffs, (int)buffType);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int GetBuffCount(BuffDef buffDef)
{
return GetBuffCount(buffDef?.buffIndex ?? BuffIndex.None);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool HasBuff(BuffIndex buffType)
{
return GetBuffCount(buffType) > 0;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool HasBuff(BuffDef buffDef)
{
return HasBuff(buffDef?.buffIndex ?? BuffIndex.None);
}
public void AddTimedBuffAuthority(BuffIndex buffType, float duration)
{
if (NetworkServer.active)
{
AddTimedBuff(buffType, duration);
}
else
{
CallCmdAddTimedBuff(buffType, duration);
}
}
[Command]
public void CmdAddTimedBuff(BuffIndex buffType, float duration)
{
AddTimedBuff(buffType, duration);
}
[Server]
public void AddTimedBuff(BuffDef buffDef, float duration, int maxStacks)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::AddTimedBuff(RoR2.BuffDef,System.Single,System.Int32)' called on client");
}
else
{
if (ImmuneToDebuffBehavior.OverrideDebuff(buffDef, this))
{
return;
}
if (GetBuffCount(buffDef) < maxStacks)
{
AddTimedBuff(buffDef, duration);
return;
}
int num = -1;
float num2 = duration;
for (int i = 0; i < timedBuffs.Count; i++)
{
if (timedBuffs[i].buffIndex == buffDef.buffIndex && timedBuffs[i].timer < num2)
{
num = i;
num2 = timedBuffs[i].timer;
}
}
if (num >= 0)
{
timedBuffs[num].timer = duration;
}
}
}
[Server]
public void AddTimedBuff(BuffDef buffDef, float duration)
{
BuffIndex buffType;
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::AddTimedBuff(RoR2.BuffDef,System.Single)' called on client");
}
else
{
if ((object)buffDef == null || ImmuneToDebuffBehavior.OverrideDebuff(buffDef, this))
{
return;
}
buffType = buffDef.buffIndex;
if (buffType == BuffIndex.None)
{
return;
}
if (buffDef == RoR2Content.Buffs.AttackSpeedOnCrit)
{
int num = (inventory ? inventory.GetItemCount(RoR2Content.Items.AttackSpeedOnCrit) : 0);
int num2 = 1 + num * 2;
int num3 = 0;
int num4 = -1;
float num5 = 999f;
for (int i = 0; i < timedBuffs.Count; i++)
{
if (timedBuffs[i].buffIndex == buffType)
{
num3++;
if (timedBuffs[i].timer < num5)
{
num4 = i;
num5 = timedBuffs[i].timer;
}
}
}
if (num3 < num2)
{
timedBuffs.Add(new TimedBuff
{
buffIndex = buffType,
timer = duration
});
AddBuff(buffType);
ChildLocator component = modelLocator.modelTransform.GetComponent<ChildLocator>();
if ((bool)component)
{
Transform obj = component.FindChild("HandL");
Transform transform = component.FindChild("HandR");
GameObject effectPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/WolfProcEffect");
if ((bool)obj)
{
EffectManager.SimpleMuzzleFlash(effectPrefab, base.gameObject, "HandL", transmit: true);
}
if ((bool)transform)
{
EffectManager.SimpleMuzzleFlash(effectPrefab, base.gameObject, "HandR", transmit: true);
}
}
}
else if (num4 > -1)
{
timedBuffs[num4].timer = duration;
}
EntitySoundManager.EmitSoundServer(CommonAssets.procCritAttackSpeedSounds[Mathf.Min(CommonAssets.procCritAttackSpeedSounds.Length - 1, num3)].index, networkIdentity);
}
else if (buffDef == RoR2Content.Buffs.BeetleJuice)
{
if (RefreshStacks() < 10)
{
timedBuffs.Add(new TimedBuff
{
buffIndex = buffType,
timer = duration
});
AddBuff(buffType);
}
}
else if (buffDef == RoR2Content.Buffs.NullifyStack)
{
if (HasBuff(RoR2Content.Buffs.Nullified))
{
return;
}
int num6 = 0;
for (int j = 0; j < timedBuffs.Count; j++)
{
if (timedBuffs[j].buffIndex == buffType)
{
num6++;
if (timedBuffs[j].timer < duration)
{
timedBuffs[j].timer = duration;
}
}
}
if (num6 < 2)
{
timedBuffs.Add(new TimedBuff
{
buffIndex = buffType,
timer = duration
});
AddBuff(buffType);
}
else
{
ClearTimedBuffs(RoR2Content.Buffs.NullifyStack.buffIndex);
AddTimedBuff(RoR2Content.Buffs.Nullified.buffIndex, 3f);
}
}
else if (buffDef == RoR2Content.Buffs.AffixHauntedRecipient)
{
if (!HasBuff(RoR2Content.Buffs.AffixHaunted))
{
DefaultBehavior();
}
}
else if (buffDef == DLC2Content.Buffs.EliteBeadCorruption)
{
if (!HasBuff(DLC2Content.Buffs.EliteBead))
{
DefaultBehavior();
}
}
else if (buffDef == RoR2Content.Buffs.LunarDetonationCharge)
{
RefreshStacks();
DefaultBehavior();
}
else if (buffDef == RoR2Content.Buffs.Overheat)
{
RefreshStacks();
DefaultBehavior();
}
else if (buffDef == DLC2Content.Buffs.BoostAllStatsBuff)
{
RefreshStacks();
DefaultBehavior();
}
else
{
DefaultBehavior();
}
}
void DefaultBehavior()
{
bool flag = false;
if (!buffDef.canStack)
{
for (int k = 0; k < timedBuffs.Count; k++)
{
if (timedBuffs[k].buffIndex == buffType)
{
flag = true;
timedBuffs[k].timer = Mathf.Max(timedBuffs[k].timer, duration);
break;
}
}
}
if (!flag)
{
timedBuffs.Add(new TimedBuff
{
buffIndex = buffType,
timer = duration
});
AddBuff(buffType);
}
if ((bool)buffDef.startSfx)
{
EntitySoundManager.EmitSoundServer(buffDef.startSfx.index, networkIdentity);
}
}
int RefreshStacks()
{
int num7 = 0;
for (int l = 0; l < timedBuffs.Count; l++)
{
TimedBuff timedBuff = timedBuffs[l];
if (timedBuff.buffIndex == buffType)
{
num7++;
if (timedBuff.timer < duration)
{
timedBuff.timer = duration;
}
}
}
return num7;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[Server]
public void AddTimedBuff(BuffIndex buffIndex, float duration)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::AddTimedBuff(RoR2.BuffIndex,System.Single)' called on client");
}
else
{
AddTimedBuff(BuffCatalog.GetBuffDef(buffIndex), duration);
}
}
[Server]
public void ClearTimedBuffs(BuffIndex buffType)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::ClearTimedBuffs(RoR2.BuffIndex)' called on client");
return;
}
for (int num = timedBuffs.Count - 1; num >= 0; num--)
{
TimedBuff timedBuff = timedBuffs[num];
if (timedBuff.buffIndex == buffType)
{
timedBuffs.RemoveAt(num);
RemoveBuff(timedBuff.buffIndex);
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[Server]
public void ClearTimedBuffs(BuffDef buffDef)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::ClearTimedBuffs(RoR2.BuffDef)' called on client");
}
else
{
ClearTimedBuffs(buffDef?.buffIndex ?? BuffIndex.None);
}
}
[Server]
public void RemoveOldestTimedBuff(BuffIndex buffType)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::RemoveOldestTimedBuff(RoR2.BuffIndex)' called on client");
return;
}
float num = float.NegativeInfinity;
int num2 = -1;
for (int num3 = timedBuffs.Count - 1; num3 >= 0; num3--)
{
TimedBuff timedBuff = timedBuffs[num3];
if (timedBuff.buffIndex == buffType && num < timedBuff.timer)
{
num = timedBuff.timer;
num2 = num3;
}
}
if (num2 > 0)
{
timedBuffs.RemoveAt(num2);
RemoveBuff(buffType);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[Server]
public void RemoveOldestTimedBuff(BuffDef buffDef)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::RemoveOldestTimedBuff(RoR2.BuffDef)' called on client");
}
else
{
RemoveOldestTimedBuff(buffDef?.buffIndex ?? BuffIndex.None);
}
}
[Server]
private void UpdateBuffs(float deltaTime)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::UpdateBuffs(System.Single)' called on client");
return;
}
for (int num = timedBuffs.Count - 1; num >= 0; num--)
{
TimedBuff timedBuff = timedBuffs[num];
timedBuff.timer -= deltaTime;
if (timedBuff.timer <= 0f)
{
timedBuffs.RemoveAt(num);
RemoveBuff(timedBuff.buffIndex);
}
}
}
[Client]
private void OnClientBuffsChanged()
{
if (!NetworkClient.active)
{
Debug.LogWarning("[Client] function 'System.Void RoR2.CharacterBody::OnClientBuffsChanged()' called on server");
return;
}
bool num = HasBuff(RoR2Content.Buffs.WarCryBuff);
if (!num && (bool)warCryEffectInstance)
{
UnityEngine.Object.Destroy(warCryEffectInstance);
}
if (num && !warCryEffectInstance)
{
Transform transform = (mainHurtBox ? mainHurtBox.transform : this.transform);
if ((bool)transform)
{
warCryEffectInstance = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/WarCryEffect"), transform.position, Quaternion.identity, transform);
}
}
if ((bool)inventory && inventory.GetItemCount(DLC2Content.Items.IncreaseDamageOnMultiKill) > 0)
{
int buffCount = GetBuffCount(DLC2Content.Buffs.IncreaseDamageBuff);
if ((bool)increaseDamageOnMultiKillItemDisplayUpdater)
{
increaseDamageOnMultiKillItemDisplayUpdater.UpdateKillCounterText(buffCount);
}
if (previousMultiKillBuffCount < buffCount)
{
Util.PlaySound("Play_item_proc_increaseDamageMultiKill", base.gameObject);
}
previousMultiKillBuffCount = buffCount;
}
}
public NetworkInstanceId GetMasterObjectId()
{
return masterObjectId;
}
private void GetSelectedCharacterType()
{
}
private void UpdateHurtBoxesEnabled()
{
bool flag = ((bool)inventory && inventory.GetItemCount(RoR2Content.Items.Ghost) > 0) || HasBuff(RoR2Content.Buffs.Intangible);
if (flag == disablingHurtBoxes)
{
return;
}
if ((bool)hurtBoxGroup)
{
if (flag)
{
HurtBoxGroup obj = hurtBoxGroup;
int hurtBoxesDeactivatorCounter = obj.hurtBoxesDeactivatorCounter + 1;
obj.hurtBoxesDeactivatorCounter = hurtBoxesDeactivatorCounter;
}
else
{
HurtBoxGroup obj2 = hurtBoxGroup;
int hurtBoxesDeactivatorCounter = obj2.hurtBoxesDeactivatorCounter - 1;
obj2.hurtBoxesDeactivatorCounter = hurtBoxesDeactivatorCounter;
}
}
disablingHurtBoxes = flag;
}
private void OnInventoryChanged()
{
EquipmentIndex currentEquipmentIndex = inventory.currentEquipmentIndex;
if (currentEquipmentIndex != previousEquipmentIndex)
{
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(previousEquipmentIndex);
EquipmentDef equipmentDef2 = EquipmentCatalog.GetEquipmentDef(currentEquipmentIndex);
if (equipmentDef != null)
{
OnEquipmentLost(equipmentDef);
}
if (equipmentDef2 != null)
{
OnEquipmentGained(equipmentDef2);
}
previousEquipmentIndex = currentEquipmentIndex;
}
statsDirty = true;
UpdateHurtBoxesEnabled();
AddItemBehavior<AffixHauntedBehavior>(HasBuff(RoR2Content.Buffs.AffixHaunted) ? 1 : 0);
AddItemBehavior<AffixEarthBehavior>(HasBuff(DLC1Content.Buffs.EliteEarth) ? 1 : 0);
AddItemBehavior<AffixVoidBehavior>(HasBuff(DLC1Content.Buffs.EliteVoid) ? 1 : 0);
AddItemBehavior<AffixBeadBehavior>(HasBuff(DLC2Content.Buffs.EliteBead) ? 1 : 0);
AddItemBehavior<AffixAurelioniteBehavior>(HasBuff(DLC2Content.Buffs.EliteAurelionite) ? 1 : 0);
if (NetworkServer.active)
{
AddItemBehavior<QuestVolatileBatteryBehaviorServer>((inventory.GetEquipment(inventory.activeEquipmentSlot).equipmentDef == RoR2Content.Equipment.QuestVolatileBattery) ? 1 : 0);
AddItemBehavior<ElementalRingsBehavior>(inventory.GetItemCount(RoR2Content.Items.IceRing) + inventory.GetItemCount(RoR2Content.Items.FireRing));
AddItemBehavior<ElementalRingVoidBehavior>(inventory.GetItemCount(DLC1Content.Items.ElementalRingVoid));
AddItemBehavior<OutOfCombatArmorBehavior>(inventory.GetItemCount(DLC1Content.Items.OutOfCombatArmor));
AddItemBehavior<PrimarySkillShurikenBehavior>(inventory.GetItemCount(DLC1Content.Items.PrimarySkillShuriken));
AddItemBehavior<MushroomVoidBehavior>(inventory.GetItemCount(DLC1Content.Items.MushroomVoid));
AddItemBehavior<BearVoidBehavior>(inventory.GetItemCount(DLC1Content.Items.BearVoid));
AddItemBehavior<LunarSunBehavior>(inventory.GetItemCount(DLC1Content.Items.LunarSun));
AddItemBehavior<VoidMegaCrabItemBehavior>(inventory.GetItemCount(DLC1Content.Items.VoidMegaCrabItem));
AddItemBehavior<DroneWeaponsBehavior>(inventory.GetItemCount(DLC1Content.Items.DroneWeapons));
AddItemBehavior<DroneWeaponsBoostBehavior>(inventory.GetItemCount(DLC1Content.Items.DroneWeaponsBoost));
AddItemBehavior<MeteorAttackOnHighDamageBehavior>(inventory.GetItemCount(DLC2Content.Items.MeteorAttackOnHighDamage));
AddItemBehavior<TeleportOnLowHealthBehavior>(inventory.GetItemCount(DLC2Content.Items.TeleportOnLowHealth));
}
executeEliteHealthFraction = Util.ConvertAmplificationPercentageIntoReductionPercentage(13f * (float)inventory.GetItemCount(RoR2Content.Items.ExecuteLowHealthElite)) / 100f;
if ((bool)skillLocator)
{
ReplaceSkillIfItemPresent(skillLocator.primary, RoR2Content.Items.LunarPrimaryReplacement.itemIndex, CommonAssets.lunarPrimaryReplacementSkillDef);
ReplaceSkillIfItemPresent(skillLocator.secondary, RoR2Content.Items.LunarSecondaryReplacement.itemIndex, CommonAssets.lunarSecondaryReplacementSkillDef);
ReplaceSkillIfItemPresent(skillLocator.special, RoR2Content.Items.LunarSpecialReplacement.itemIndex, CommonAssets.lunarSpecialReplacementSkillDef);
ReplaceSkillIfItemPresent(skillLocator.utility, RoR2Content.Items.LunarUtilityReplacement.itemIndex, CommonAssets.lunarUtilityReplacementSkillDef);
}
this.onInventoryChanged?.Invoke();
CharacterBody.onBodyInventoryChangedGlobal?.Invoke(this);
UpdateItemAvailability();
}
private void ReplaceSkillIfItemPresent(GenericSkill skill, ItemIndex itemIndex, SkillDef skillDef)
{
if ((bool)skill)
{
if (inventory.GetItemCount(itemIndex) > 0 && (bool)skillDef)
{
skill.SetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Replacement);
}
else
{
skill.UnsetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Replacement);
}
}
}
private void OnEquipmentLost(EquipmentDef equipmentDef)
{
if (NetworkServer.active && (object)equipmentDef.passiveBuffDef != null)
{
RemoveBuff(equipmentDef.passiveBuffDef);
}
}
private void OnEquipmentGained(EquipmentDef equipmentDef)
{
if (NetworkServer.active && (object)equipmentDef.passiveBuffDef != null)
{
AddBuff(equipmentDef.passiveBuffDef);
}
}
private void UpdateMasterLink()
{
if (!linkedToMaster && (bool)master && (bool)master)
{
master.OnBodyStart(this);
linkedToMaster = true;
skinIndex = master.loadout.bodyLoadoutManager.GetSkinIndex(bodyIndex);
}
}
public static void Init()
{
AssetReferences.Resolve();
}
private void Awake()
{
transform = base.transform;
rigidbody = GetComponent<Rigidbody>();
networkIdentity = GetComponent<NetworkIdentity>();
teamComponent = GetComponent<TeamComponent>();
healthComponent = GetComponent<HealthComponent>();
equipmentSlot = GetComponent<EquipmentSlot>();
skillLocator = GetComponent<SkillLocator>();
modelLocator = GetComponent<ModelLocator>();
characterMotor = GetComponent<CharacterMotor>();
characterDirection = GetComponent<CharacterDirection>();
inputBank = GetComponent<InputBankTest>();
sfxLocator = GetComponent<SfxLocator>();
activeBuffsList = BuffCatalog.GetPerBuffBuffer<BuffIndex>();
buffs = BuffCatalog.GetPerBuffBuffer<int>();
if ((bool)modelLocator)
{
modelLocator.onModelChanged += OnModelChanged;
OnModelChanged(modelLocator.modelTransform);
}
radius = 1f;
CapsuleCollider component = GetComponent<CapsuleCollider>();
if ((bool)component)
{
radius = component.radius;
}
else
{
SphereCollider component2 = GetComponent<SphereCollider>();
if ((bool)component2)
{
radius = component2.radius;
}
}
try
{
CharacterBody.onBodyAwakeGlobal?.Invoke(this);
}
catch (Exception message)
{
Debug.LogError(message);
}
}
private void OnModelChanged(Transform modelTransform)
{
hurtBoxGroup = null;
mainHurtBox = null;
coreTransform = transform;
if ((bool)modelTransform)
{
hurtBoxGroup = modelTransform.GetComponent<HurtBoxGroup>();
if ((bool)hurtBoxGroup)
{
mainHurtBox = hurtBoxGroup.mainHurtBox;
if ((bool)mainHurtBox)
{
coreTransform = mainHurtBox.transform;
}
}
}
if ((bool)overrideCoreTransform)
{
coreTransform = overrideCoreTransform;
}
}
private void Start()
{
UpdateAuthority();
localStartTime = Run.FixedTimeStamp.now;
bool num = (bodyFlags & BodyFlags.Masterless) != 0;
outOfCombatStopwatch = float.PositiveInfinity;
outOfDangerStopwatch = float.PositiveInfinity;
notMovingStopwatch = 0f;
if (NetworkServer.active)
{
outOfCombat = true;
outOfDanger = true;
}
RecalculateStats();
UpdateMasterLink();
if (num)
{
healthComponent.Networkhealth = maxHealth;
}
if ((bool)sfxLocator && healthComponent.alive)
{
Util.PlaySound(sfxLocator.aliveLoopStart, base.gameObject);
}
if (!doNotReassignToTeamBasedCollisionLayer)
{
base.gameObject.layer = LayerIndex.GetAppropriateLayerForTeam(teamComponent.teamIndex);
if (characterMotor != null)
{
characterMotor.Motor.RebuildCollidableLayers();
}
}
CharacterBody.onBodyStartGlobal?.Invoke(this);
if ((bool)master && NetworkServer.active)
{
if (master.devotionInventoryPrefab == null)
{
_ = master.isDevotedMinion;
}
if (isPlayerControlled && (bool)master.devotionInventoryPrefab)
{
_ = master.devotionInventoryPrefab != null;
}
int num2 = ((inventory != null) ? inventory.GetItemCount(DLC2Content.Items.GoldOnStageStart) : 0);
if (num2 > 0)
{
TransmitItemBehavior(new NetworkItemBehaviorData(DLC2Content.Items.GoldOnStageStart.itemIndex, 0f));
uint difficultyScaledCost = (uint)Run.instance.GetDifficultyScaledCost((int)(50f + level * 1.5f * (float)num2));
master.GiveMoney(difficultyScaledCost);
}
}
}
public void Update()
{
float deltaTime = Time.deltaTime;
outOfCombatStopwatch += deltaTime;
outOfDangerStopwatch += deltaTime;
aimTimer = Mathf.Max(aimTimer - deltaTime, 0f);
UpdateOutOfCombatAndDanger();
UpdateSpreadBloom(deltaTime);
DoItemUpdates(deltaTime);
UpdateNotMoving(deltaTime);
HandleLavaDamage(deltaTime);
}
private void UpdateNotMoving(float deltaTime)
{
if (NetworkServer.active)
{
Vector3 position = transform.position;
float num = 0.1f * deltaTime;
if ((position - previousPosition).sqrMagnitude <= num * num)
{
notMovingStopwatch += deltaTime;
}
else
{
notMovingStopwatch = 0f;
}
previousPosition = position;
}
}
private void DoItemUpdates(float deltaTime)
{
if ((bodyFlags & BodyFlags.IgnoreItemUpdates) == 0)
{
if (NetworkServer.active)
{
UpdateMultiKill(deltaTime);
UpdateHelfire(deltaTime);
UpdateAffixPoison(deltaTime);
UpdateAffixLunar(deltaTime);
UpdateLowerHealthHigherDamage();
UpdateDelayedDamage(deltaTime);
UpdateSecondHalfOfDamage(deltaTime);
}
UpdateFireTrail();
}
}
private void UpdateOutOfCombatAndDanger()
{
bool active = NetworkServer.active;
bool flag = outOfCombat;
bool flag2 = flag;
if (active || hasEffectiveAuthority)
{
flag2 = outOfCombatStopwatch >= 5f;
if (outOfCombat != flag2)
{
if (NetworkServer.active)
{
SetDirtyBit(4u);
}
outOfCombat = flag2;
statsDirty = true;
}
}
if (active)
{
bool flag3 = outOfDangerStopwatch >= 7f;
bool flag4 = outOfDanger;
bool flag5 = flag && flag4;
bool num = flag2 && flag3;
if (outOfDanger != flag3)
{
SetDirtyBit(8u);
outOfDanger = flag3;
statsDirty = true;
}
if (num && !flag5)
{
OnOutOfCombatAndDangerServer();
}
}
}
[Command]
public void CmdSetInLava(bool b)
{
inLava = b;
}
public void SetInLava(bool b)
{
if (inLava != b)
{
if (!NetworkServer.active && base.hasAuthority)
{
CallCmdSetInLava(b);
}
inLava = b;
}
}
public void InflictLavaDamage()
{
DamageInfo damageInfo = new DamageInfo();
damageInfo.damage = 10f;
if (isChampion || isBoss)
{
damageInfo.damage = healthComponent.fullCombinedHealth / 100f;
}
else if (teamComponent.teamIndex == TeamIndex.Monster || teamComponent.teamIndex == TeamIndex.Void)
{
damageInfo.damage = healthComponent.fullCombinedHealth / 50f;
}
else
{
damageInfo.damage = healthComponent.fullCombinedHealth / 10f;
}
damageInfo.damageType = DamageType.IgniteOnHit;
damageInfo.position = footPosition;
healthComponent.TakeDamage(damageInfo);
}
public void HandleLavaDamage(float deltaTime)
{
bool flag = (bodyFlags & BodyFlags.ImmuneToLava) != 0;
if (inLava && NetworkServer.active)
{
lavaTimer -= deltaTime;
if (lavaTimer <= 0f && !flag)
{
InflictLavaDamage();
lavaTimer = lavaCooldown;
}
}
else
{
lavaTimer = 0f;
}
}
private void UpdateItemAvailability()
{
if ((bool)inventory)
{
itemAvailability.helfireCount = inventory.GetItemCount(JunkContent.Items.BurnNearby);
}
itemAvailability.hasFireTrail = HasBuff(RoR2Content.Buffs.AffixRed);
itemAvailability.hasAffixLunar = HasBuff(RoR2Content.Buffs.AffixLunar);
itemAvailability.hasAffixPoison = HasBuff(RoR2Content.Buffs.AffixPoison);
}
public void FixedUpdate()
{
float fixedDeltaTime = Time.fixedDeltaTime;
bool flag = (bodyFlags & BodyFlags.IgnoreItemUpdates) == 0;
if (NetworkServer.active)
{
if (flag)
{
UpdateBuffs(fixedDeltaTime);
}
UpdateOutOfCombatAndDanger();
}
if (statsDirty)
{
RecalculateStats();
}
}
public void OnDeathStart()
{
base.enabled = false;
if ((bool)sfxLocator)
{
Util.PlaySound(sfxLocator.aliveLoopStop, base.gameObject);
}
if (NetworkServer.active && (bool)currentVehicle)
{
currentVehicle.EjectPassenger(base.gameObject);
}
if ((bool)master)
{
master.OnBodyDeath(this);
}
ModelLocator component = GetComponent<ModelLocator>();
if (!component)
{
return;
}
Transform modelTransform = component.modelTransform;
if ((bool)modelTransform)
{
CharacterModel component2 = modelTransform.GetComponent<CharacterModel>();
if ((bool)component2)
{
component2.OnDeath();
}
}
}
public void OnTakeDamageServer(DamageReport damageReport)
{
if (damageReport.damageDealt > 0f)
{
outOfDangerStopwatch = 0f;
}
if ((bool)master)
{
master.OnBodyDamaged(damageReport);
}
}
public void OnSkillActivated(GenericSkill skill)
{
if (skill.isCombatSkill)
{
outOfCombatStopwatch = 0f;
}
if (hasEffectiveAuthority)
{
this.onSkillActivatedAuthority?.Invoke(skill);
}
if (NetworkServer.active)
{
this.onSkillActivatedServer?.Invoke(skill);
if (inventory.GetItemCount(DLC2Content.Items.IncreasePrimaryDamage) <= 0)
{
return;
}
if (bodyIndex == BodyCatalog.SpecialCases.RailGunner())
{
if ((object)skillLocator.primary == skill)
{
if (GetBuffCount(DLC2Content.Buffs.IncreasePrimaryDamageBuff) > 0 && !BaseScopeState.inScope)
{
luminousShotReady = true;
}
}
else
{
luminousShotReady = false;
}
if ((object)skillLocator.primary == skill && BaseScopeState.inScope)
{
AddIncreasePrimaryDamageStack();
}
}
else
{
if (!skill.skillDef.autoHandleLuminousShot)
{
return;
}
if ((object)skillLocator.secondary == skill)
{
AddIncreasePrimaryDamageStack();
}
else if ((object)skillLocator.primary == skill)
{
if (GetBuffCount(DLC2Content.Buffs.IncreasePrimaryDamageBuff) > 0)
{
luminousShotReady = true;
}
else
{
luminousShotReady = false;
}
}
}
}
else
{
CallCmdOnSkillActivated((sbyte)skillLocator.FindSkillSlot(skill));
}
}
public void OnDestroy()
{
try
{
CharacterBody.onBodyDestroyGlobal?.Invoke(this);
}
catch (Exception message)
{
Debug.LogError(message);
}
if ((bool)sfxLocator)
{
Util.PlaySound(sfxLocator.aliveLoopStop, base.gameObject);
}
if ((object)modelLocator != null)
{
modelLocator.onModelChanged -= OnModelChanged;
}
if ((bool)inventory)
{
inventory.onInventoryChanged -= OnInventoryChanged;
}
if ((bool)master)
{
master.OnBodyDestroyed(this);
}
}
public float GetNormalizedThreatValue()
{
if ((bool)Run.instance)
{
return (master ? ((float)master.money) : 0f) * Run.instance.oneOverCompensatedDifficultyCoefficientSquared;
}
return 0f;
}
private void OnEnable()
{
instancesList.Add(this);
}
private void OnDisable()
{
instancesList.Remove(this);
}
private void OnValidate()
{
if (autoCalculateLevelStats)
{
PerformAutoCalculateLevelStats();
}
if (!Application.isPlaying && bodyIndex != BodyIndex.None)
{
bodyIndex = BodyIndex.None;
}
}
private void UpdateAuthority()
{
hasEffectiveAuthority = Util.HasEffectiveAuthority(base.gameObject);
}
public override void OnStartAuthority()
{
UpdateAuthority();
}
public override void OnStopAuthority()
{
UpdateAuthority();
}
private void OnSprintStart()
{
if ((bool)sfxLocator)
{
Util.PlaySound(sfxLocator.sprintLoopStart, base.gameObject);
}
}
private void OnSprintStop()
{
if ((bool)sfxLocator)
{
Util.PlaySound(sfxLocator.sprintLoopStop, base.gameObject);
}
}
[Command]
private void CmdUpdateSprint(bool newIsSprinting)
{
isSprinting = newIsSprinting;
}
[Command]
private void CmdOnSkillActivated(sbyte skillIndex)
{
OnSkillActivated(skillLocator.GetSkill((SkillSlot)skillIndex));
}
private void OnOutOfDangerChanged()
{
if (outOfDanger && healthComponent.shield != healthComponent.fullShield)
{
Util.PlaySound("Play_item_proc_personal_shield_recharge", base.gameObject);
}
}
[Server]
private void OnOutOfCombatAndDangerServer()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::OnOutOfCombatAndDangerServer()' called on client");
}
}
[Server]
public bool GetNotMoving()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Boolean RoR2.CharacterBody::GetNotMoving()' called on client");
return false;
}
return notMovingStopwatch >= 1f;
}
public void PerformAutoCalculateLevelStats()
{
levelMaxHealth = Mathf.Round(baseMaxHealth * 0.3f);
levelMaxShield = Mathf.Round(baseMaxShield * 0.3f);
levelRegen = baseRegen * 0.2f;
levelMoveSpeed = 0f;
levelJumpPower = 0f;
levelDamage = baseDamage * 0.2f;
levelAttackSpeed = 0f;
levelCrit = 0f;
levelArmor = 0f;
}
public void MarkAllStatsDirty()
{
statsDirty = true;
}
private void UpdateLowerHealthHigherDamageVFX()
{
if ((bool)lowerHealthHigherDamageSteam)
{
ParticleSystem.EmissionModule emission = lowerHealthHigherDamageSteam.GetComponent<ParticleSystem>().emission;
emission.rateOverTime = 35f;
}
}
public void UpdateLowerHealthHigherDamage()
{
if (!inventory)
{
return;
}
int itemCount = inventory.GetItemCount(DLC2Content.Items.LowerHealthHigherDamage);
if (NetworkServer.active)
{
if (itemCount > 0)
{
if ((bool)inventory && healthComponent.health > 0f && teamComponent.teamIndex == TeamIndex.Player)
{
float normalizedHealth = healthComponent.GetNormalizedHealth();
if ((double)normalizedHealth <= 0.5 && !HasBuff(DLC2Content.Buffs.LowerHealthHigherDamageBuff))
{
AddBuff(DLC2Content.Buffs.LowerHealthHigherDamageBuff);
Util.PlaySound("Play_item_proc_lowerHealthHigherDamage_proc", base.gameObject);
TransmitItemBehavior(new NetworkItemBehaviorData(DLC2Content.Items.LowerHealthHigherDamage.itemIndex, 1f));
}
else if (HasBuff(DLC2Content.Buffs.LowerHealthHigherDamageBuff) && (double)normalizedHealth > 0.5)
{
RemoveBuff(DLC2Content.Buffs.LowerHealthHigherDamageBuff);
TransmitItemBehavior(new NetworkItemBehaviorData(DLC2Content.Items.LowerHealthHigherDamage.itemIndex, 0f));
}
}
}
else if (HasBuff(DLC2Content.Buffs.LowerHealthHigherDamageBuff))
{
RemoveBuff(DLC2Content.Buffs.LowerHealthHigherDamageBuff);
TransmitItemBehavior(new NetworkItemBehaviorData(DLC2Content.Items.LowerHealthHigherDamage.itemIndex, 0f));
}
}
else if (itemCount == 0 && HasBuff(DLC2Content.Buffs.LowerHealthHigherDamageBuff) && healthComponent.health > 0f && teamComponent.teamIndex == TeamIndex.Player && (double)healthComponent.GetNormalizedHealth() > 0.5)
{
RemoveBuff(DLC2Content.Buffs.LowerHealthHigherDamageBuff);
TransmitItemBehavior(new NetworkItemBehaviorData(DLC2Content.Items.LowerHealthHigherDamage.itemIndex, 0f));
}
}
private void SetBoostAllStatsStartTimer(float t)
{
if (!boostAllStatsTimerStarted)
{
boostAllStatsStartTimer = t;
boostAllStatsTimer = boostAllStatsStartTimer;
boostAllStatsTimerStarted = true;
}
}
private void SetBoostAllStatsCoolDownTimer(float t)
{
if (boostAllStatsCoolDownTimerStarted)
{
boostAllStatsCoolDownStartTimer = t;
boostAllStatsCoolDownTimer = boostAllStatsCoolDownStartTimer;
}
}
private float CalculateBoostAllStatsTriggerChance(int i)
{
boostAllStatsTriggerChance = boostAllStatsDefaultTriggerChance + boostAllStatsTriggerIncrease * (float)(i - 1);
if ((double)boostAllStatsTriggerChance >= 0.5)
{
boostAllStatsTriggerChance = 0.5f;
}
return boostAllStatsTriggerChance;
}
private void UpdateBoostAllStatsTimer(float t)
{
if (!NetworkServer.active || !inventory)
{
return;
}
int itemCount = inventory.GetItemCount(DLC2Content.Items.BoostAllStats);
if (!boostAllStatsCoolDownTimerStarted && itemCount > 0)
{
SetBoostAllStatsStartTimer(t);
boostAllStatsTimer += t;
if (boostAllStatsTimer >= boostAllStatsStartTimer + boostAllStatsTriggerTimer)
{
if (RoR2Application.rng.RangeFloat(0f, 1f) <= CalculateBoostAllStatsTriggerChance(inventory.GetItemCount(DLC2Content.Items.BoostAllStats)))
{
AddBuff(DLC2Content.Buffs.BoostAllStatsBuff);
RecalculateStats();
boostAllStatsTimerStarted = false;
boostAllStatsCoolDownTimerStarted = true;
SetBoostAllStatsCoolDownTimer(t);
}
else
{
boostAllStatsTimerStarted = false;
boostAllStatsCoolDownTimerStarted = false;
}
}
}
else if (boostAllStatsCoolDownTimerStarted)
{
boostAllStatsCoolDownTimer += t;
if (boostAllStatsCoolDownTimer >= boostAllStatsStartTimer + boostAllStatsCoolDownTriggerTimer)
{
RemoveBuff(DLC2Content.Buffs.BoostAllStatsBuff);
RecalculateStats();
boostAllStatsCoolDownTimerStarted = false;
}
}
}
public void RecalculateStats()
{
if (!Run.instance)
{
return;
}
float num = level;
TeamManager.instance.GetTeamExperience(teamComponent.teamIndex);
float num2 = TeamManager.instance.GetTeamLevel(teamComponent.teamIndex);
int num3 = 0;
int num4 = 0;
int num5 = 0;
int num6 = 0;
int num7 = 0;
int num8 = 0;
int num9 = 0;
int num10 = 0;
int num11 = 0;
int num12 = 0;
int num13 = 0;
int num14 = 0;
int num15 = 0;
int num16 = 0;
int num17 = 0;
int num18 = 0;
int num19 = 0;
int num20 = 0;
int num21 = 0;
int num22 = 0;
int num23 = 0;
int num24 = 0;
int num25 = 0;
int num26 = 0;
int num27 = 0;
int num28 = 0;
int num29 = 0;
int num30 = 0;
int num31 = 0;
int num32 = 0;
int num33 = 0;
int num34 = 0;
int num35 = 0;
int num36 = 0;
int num37 = 0;
int num38 = 0;
int num39 = 0;
int num40 = 0;
int num41 = 0;
int num42 = 0;
int num43 = 0;
int num44 = 0;
int num45 = 0;
int num46 = 0;
int num47 = 0;
int num48 = 0;
int num49 = 0;
int num50 = 0;
EquipmentIndex equipmentIndex = EquipmentIndex.None;
uint num51 = 0u;
int num52 = 0;
int num53 = 0;
int num54 = 0;
int num55 = 0;
if ((bool)inventory)
{
num3 = inventory.GetItemCount(RoR2Content.Items.LevelBonus);
num4 = inventory.GetItemCount(RoR2Content.Items.Infusion);
num5 = inventory.GetItemCount(RoR2Content.Items.HealWhileSafe);
num6 = inventory.GetItemCount(RoR2Content.Items.PersonalShield);
num7 = inventory.GetItemCount(RoR2Content.Items.Hoof);
num8 = inventory.GetItemCount(RoR2Content.Items.SprintOutOfCombat);
num9 = inventory.GetItemCount(RoR2Content.Items.Feather);
num10 = inventory.GetItemCount(RoR2Content.Items.Syringe);
num11 = inventory.GetItemCount(RoR2Content.Items.CritGlasses);
num12 = inventory.GetItemCount(RoR2Content.Items.AttackSpeedOnCrit);
num13 = inventory.GetItemCount(JunkContent.Items.CooldownOnCrit);
num14 = inventory.GetItemCount(RoR2Content.Items.HealOnCrit);
num15 = inventory.GetItemCount(RoR2Content.Items.ShieldOnly);
num16 = inventory.GetItemCount(RoR2Content.Items.AlienHead);
num17 = inventory.GetItemCount(RoR2Content.Items.Knurl);
num18 = inventory.GetItemCount(RoR2Content.Items.BoostHp);
num19 = inventory.GetItemCount(JunkContent.Items.CritHeal);
num20 = inventory.GetItemCount(RoR2Content.Items.SprintBonus);
num21 = inventory.GetItemCount(RoR2Content.Items.SecondarySkillMagazine);
num23 = inventory.GetItemCount(RoR2Content.Items.SprintArmor);
num24 = inventory.GetItemCount(RoR2Content.Items.UtilitySkillMagazine);
num25 = inventory.GetItemCount(RoR2Content.Items.HealthDecay);
num27 = inventory.GetItemCount(RoR2Content.Items.TonicAffliction);
num28 = inventory.GetItemCount(RoR2Content.Items.LunarDagger);
num26 = inventory.GetItemCount(RoR2Content.Items.DrizzlePlayerHelper);
num29 = inventory.GetItemCount(RoR2Content.Items.MonsoonPlayerHelper);
num30 = inventory.GetItemCount(RoR2Content.Items.Pearl);
num31 = inventory.GetItemCount(RoR2Content.Items.ShinyPearl);
num32 = inventory.GetItemCount(RoR2Content.Items.InvadingDoppelganger);
num33 = inventory.GetItemCount(RoR2Content.Items.CutHp);
num34 = inventory.GetItemCount(RoR2Content.Items.BoostAttackSpeed);
num35 = inventory.GetItemCount(RoR2Content.Items.BleedOnHitAndExplode);
num36 = inventory.GetItemCount(RoR2Content.Items.LunarBadLuck);
num37 = inventory.GetItemCount(RoR2Content.Items.FlatHealth);
num38 = inventory.GetItemCount(RoR2Content.Items.TeamSizeDamageBonus);
num39 = inventory.GetItemCount(RoR2Content.Items.SummonedEcho);
num40 = inventory.GetItemCount(RoR2Content.Items.UseAmbientLevel);
num22 = inventory.GetItemCount(DLC1Content.Items.EquipmentMagazineVoid);
num44 = inventory.GetItemCount(DLC1Content.Items.HalfAttackSpeedHalfCooldowns);
num45 = inventory.GetItemCount(DLC1Content.Items.HalfSpeedDoubleHealth);
num41 = inventory.GetItemCount(RoR2Content.Items.BleedOnHit);
num42 = inventory.GetItemCount(DLC1Content.Items.AttackSpeedAndMoveSpeed);
num43 = inventory.GetItemCount(DLC1Content.Items.CritDamage);
num46 = inventory.GetItemCount(DLC1Content.Items.ConvertCritChanceToCritDamage);
num47 = inventory.GetItemCount(DLC1Content.Items.DroneWeaponsBoost);
num48 = inventory.GetItemCount(DLC1Content.Items.MissileVoid);
equipmentIndex = inventory.currentEquipmentIndex;
num51 = inventory.infusionBonus;
num49 = ((equipmentIndex == DLC1Content.Equipment.EliteVoidEquipment.equipmentIndex) ? 1 : 0);
num50 = inventory.GetItemCount(DLC1Content.Items.OutOfCombatArmor);
inventory.GetItemCount(DLC1Content.Items.VoidmanPassiveItem);
num52 = inventory.GetItemCount(DLC2Content.Items.LowerHealthHigherDamage);
num53 = inventory.GetItemCount(DLC2Content.Items.BoostAllStats);
inventory.GetItemCount(DLC2Content.Items.TeleportOnLowHealth);
num54 = inventory.GetItemCount(DLC2Content.Items.IncreaseDamageOnMultiKill);
inventory.GetItemCount(DLC2Content.Items.GoldOnStageStart);
num55 = inventory.GetItemCount(DLC2Content.Items.ExtraStatsOnLevelUp);
}
level = num2;
if (num40 > 0)
{
level = Math.Max(level, Run.instance.ambientLevelFloor);
}
level += num3;
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
float num56 = level - 1f;
isElite = eliteBuffCount > 0;
bool flag = HasBuff(RoR2Content.Buffs.TonicBuff);
bool num57 = HasBuff(RoR2Content.Buffs.Entangle);
bool flag2 = HasBuff(RoR2Content.Buffs.Nullified);
bool flag3 = HasBuff(RoR2Content.Buffs.LunarSecondaryRoot);
bool flag4 = teamComponent.teamIndex == TeamIndex.Player && RunArtifactManager.instance.IsArtifactEnabled(RoR2Content.Artifacts.glassArtifactDef);
bool num58 = num15 > 0 || HasBuff(RoR2Content.Buffs.AffixLunar);
bool flag5 = (object)equipmentDef != null && (object)equipmentDef == JunkContent.Equipment.EliteYellowEquipment;
hasOneShotProtection = isPlayerControlled;
int buffCount = GetBuffCount(RoR2Content.Buffs.BeetleJuice);
int buffCount2 = GetBuffCount(DLC2Content.Buffs.RevitalizeBuff);
isGlass = flag4 || num28 > 0;
canPerformBackstab = (bodyFlags & BodyFlags.HasBackstabPassive) == BodyFlags.HasBackstabPassive;
canReceiveBackstab = (bodyFlags & BodyFlags.HasBackstabImmunity) != BodyFlags.HasBackstabImmunity;
float num59 = maxHealth;
float num60 = maxShield;
if (num55 > extraStatsOnLevelUpCountModifier && num55 > 0)
{
extraStatsOnLevelUpCountModifier = num55;
}
if (num55 < extraStatsOnLevelUpCountModifier && (bool)inventory)
{
UnityEngine.Object.Instantiate(CommonAssets.prayerBeadEffect, base.gameObject.transform.position, Quaternion.identity).transform.parent = base.gameObject.transform;
extraStatsOnLevelUpCountModifier -= num55;
float beadAppliedHealth = inventory.beadAppliedHealth;
prayerBeadCalculateAppliedStats(levelMaxHealth);
prayerBeadCalculateAppliedStats(levelMaxShield);
prayerBeadCalculateAppliedStats(levelRegen);
prayerBeadCalculateAppliedStats(levelDamage);
extraStatsOnLevelUpCountModifier = num55;
if (HasBuff(DLC2Content.Buffs.ExtraStatsOnLevelUpBuff))
{
SetBuffCount(DLC2Content.Buffs.ExtraStatsOnLevelUpBuff.buffIndex, 0);
bool gainedStats = inventory.beadAppliedHealth > beadAppliedHealth;
master.OnBeadReset(gainedStats);
}
}
HandleDisableAllSkillsDebuff();
float num61 = baseMaxHealth + levelMaxHealth * num56;
if (teamComponent.teamIndex == TeamIndex.Player && (bool)inventory && inventory.beadAppliedHealth > 0f)
{
num61 += inventory.beadAppliedHealth;
}
float num62 = 1f;
num62 += (float)num18 * 0.1f;
num62 += (float)(num30 + num31) * 0.1f;
num62 += (float)buffCount2 * 0.07f;
num62 += (float)num49 * 0.5f;
num62 += (float)num45 * 1f;
if (num4 > 0)
{
num61 += (float)num51;
}
num61 += (float)num37 * 25f;
num61 += (float)num17 * 40f;
num61 *= num62;
num61 /= (float)(num33 + 1);
if (num32 > 0)
{
num61 *= 10f;
}
if (num39 > 0)
{
num61 *= 0.1f;
}
maxHealth = num61;
float num63 = baseMaxShield + levelMaxShield * num56;
if (teamComponent.teamIndex == TeamIndex.Player && (bool)inventory && inventory.beadAppliedShield > 0f)
{
num63 += inventory.beadAppliedShield;
}
num63 += (float)num6 * 0.08f * maxHealth;
if (HasBuff(RoR2Content.Buffs.EngiShield))
{
num63 += maxHealth * 1f;
}
if (HasBuff(JunkContent.Buffs.EngiTeamShield))
{
num63 += maxHealth * 0.5f;
}
if (num48 > 0)
{
num63 += maxHealth * 0.1f;
}
if (num58)
{
num63 += maxHealth * (1.5f + (float)(num15 - 1) * 0.25f);
maxHealth = 1f;
}
if (HasBuff(RoR2Content.Buffs.AffixBlue))
{
float num64 = maxHealth * 0.5f;
maxHealth -= num64;
num63 += maxHealth;
}
maxShield = num63;
float num65 = baseRegen + levelRegen * num56;
if (teamComponent.teamIndex == TeamIndex.Player && (bool)inventory && inventory.beadAppliedRegen > 0f)
{
num65 += inventory.beadAppliedRegen;
}
float num66 = 1f + num56 * 0.2f;
float num67 = (float)num17 * 1.6f * num66;
float num68 = ((outOfDanger && num5 > 0) ? (3f * (float)num5) : 0f) * num66;
float num69 = (HasBuff(JunkContent.Buffs.MeatRegenBoost) ? 2f : 0f) * num66;
float num70 = (float)GetBuffCount(RoR2Content.Buffs.CrocoRegen) * maxHealth * 0.1f;
float num71 = (float)num31 * 0.1f * num66;
float num72 = (float)buffCount2 * 0.07f * num66;
float num73 = 1f;
if (num26 > 0)
{
num73 += 0.5f;
}
if (num29 > 0)
{
num73 -= 0.4f;
}
float num74 = (num65 + num67 + num68 + num69 + num71 + num72) * num73;
if (HasBuff(RoR2Content.Buffs.OnFire) || HasBuff(DLC1Content.Buffs.StrongerBurn))
{
num74 = Mathf.Min(0f, num74);
}
num74 += num70;
if (num58)
{
num74 = Mathf.Max(num74, 0f);
}
if (num25 > 0)
{
num74 = Mathf.Min(num74, 0f) - maxHealth / cursePenalty / (float)num25;
}
if (tamperedHeartActive)
{
num74 += tamperedHeartRegenBonus;
}
if (HasBuff(DLC2Content.Buffs.HealAndReviveRegenBuff))
{
num74 += num74 * 0.5f;
}
regen = num74;
float num75 = baseMoveSpeed + levelMoveSpeed * num56;
num75 += surfaceSpeedBoost;
float num76 = 1f;
if (flag5)
{
num75 += 2f;
}
if (isSprinting)
{
num75 *= sprintingSpeedMultiplier;
}
num76 += (float)num7 * 0.14f;
num76 += (float)num42 * 0.07f;
num76 += (float)num31 * 0.1f;
num76 += (float)buffCount2 * 0.07f;
num76 += 0.25f * (float)GetBuffCount(DLC1Content.Buffs.KillMoveSpeed);
if (teamComponent.teamIndex == TeamIndex.Monster && Run.instance.selectedDifficulty >= DifficultyIndex.Eclipse4)
{
num76 += 0.4f;
}
if (isSprinting && num20 > 0)
{
num76 += 0.25f * (float)num20 / sprintingSpeedMultiplier;
}
if (num8 > 0 && HasBuff(RoR2Content.Buffs.WhipBoost))
{
num76 += (float)num8 * 0.3f;
}
if (num39 > 0)
{
num76 += 0.66f;
}
if (HasBuff(RoR2Content.Buffs.BugWings))
{
num76 += 0.2f;
}
if (HasBuff(RoR2Content.Buffs.Warbanner))
{
num76 += 0.3f;
}
if (HasBuff(JunkContent.Buffs.EnrageAncientWisp))
{
num76 += 0.4f;
}
if (HasBuff(RoR2Content.Buffs.CloakSpeed))
{
num76 += 0.4f;
}
if (HasBuff(RoR2Content.Buffs.WarCryBuff) || HasBuff(RoR2Content.Buffs.TeamWarCry))
{
num76 += 0.5f;
}
if (HasBuff(JunkContent.Buffs.EngiTeamShield))
{
num76 += 0.3f;
}
if (HasBuff(RoR2Content.Buffs.AffixLunar))
{
num76 += 0.3f;
}
if (tamperedHeartActive)
{
num75 += num75 * tamperedHeartMSpeedBonus;
}
float num77 = 1f;
if (HasBuff(RoR2Content.Buffs.Slow50))
{
num77 += 0.5f;
}
if (HasBuff(RoR2Content.Buffs.Slow60))
{
num77 += 0.6f;
}
if (HasBuff(RoR2Content.Buffs.Slow80))
{
num77 += 0.8f;
}
if (HasBuff(RoR2Content.Buffs.ClayGoo))
{
num77 += 0.5f;
}
if (HasBuff(JunkContent.Buffs.Slow30))
{
num77 += 0.3f;
}
if (HasBuff(RoR2Content.Buffs.Cripple))
{
num77 += 1f;
}
if (HasBuff(DLC1Content.Buffs.JailerSlow))
{
num77 += 1f;
}
num77 += (float)num45 * 1f;
num75 *= num76 / num77;
if (buffCount > 0)
{
num75 *= 1f - 0.05f * (float)buffCount;
}
moveSpeed = num75;
acceleration = ((baseMoveSpeed == 0f) ? 0f : (moveSpeed / baseMoveSpeed * baseAcceleration));
if (num57 || flag2 || flag3)
{
moveSpeed = 0f;
acceleration = 80f;
}
float num78 = baseJumpPower + levelJumpPower * num56;
jumpPower = num78;
maxJumpHeight = Trajectory.CalculateApex(jumpPower);
maxJumpCount = baseJumpCount + num9;
oneShotProtectionFraction = 0.1f;
float num79 = baseDamage + levelDamage * num56;
if (teamComponent.teamIndex == TeamIndex.Player && (bool)inventory && inventory.beadAppliedDamage > 0f)
{
num79 += inventory.beadAppliedDamage;
}
float num80 = 1f;
int num81 = (inventory ? inventory.GetItemCount(RoR2Content.Items.BoostDamage) : 0);
if (num81 > 0)
{
num80 += (float)num81 * 0.1f;
}
if (num38 > 0)
{
int num82 = Math.Max(TeamComponent.GetTeamMembers(teamComponent.teamIndex).Count - 1, 0);
num80 += (float)(num82 * num38) * 1f;
}
if (buffCount > 0)
{
num80 -= 0.05f * (float)buffCount;
}
if (HasBuff(JunkContent.Buffs.GoldEmpowered))
{
num80 += 1f;
}
if (HasBuff(RoR2Content.Buffs.PowerBuff))
{
num80 += 0.5f;
}
num80 += (float)num31 * 0.1f;
num80 += (float)buffCount2 * 0.07f;
num80 += Mathf.Pow(2f, num28) - 1f;
num80 -= (float)num49 * 0.3f;
num79 *= num80;
if (num32 > 0)
{
num79 *= 0.04f;
}
if (flag4)
{
num79 *= 5f;
}
damage = num79;
damageFromRecalculateStats = damage;
if (HasBuff(DLC2Content.Buffs.LowerHealthHigherDamageBuff))
{
damage += baseDamage * (float)currentHealthLevel * 0.1f * (float)num52 * 0.5f;
}
_ = tamperedHeartActive;
if (HasBuff(DLC2Content.Buffs.IncreaseDamageBuff))
{
int buffCount3 = GetBuffCount(DLC2Content.Buffs.IncreaseDamageBuff);
float num83 = 0f;
if (buffCount3 >= 2)
{
num83 = (float)(buffCount3 * (buffCount3 + num54 * 5)) * 0.01f;
}
else if (buffCount3 == 1)
{
num83 = (float)(1 + num54 * 5) * 0.01f;
}
damage += baseDamage * num83;
if (oldComboMeter < buffCount3)
{
oldComboMeter = buffCount3;
}
}
float num84 = baseAttackSpeed + levelAttackSpeed * num56;
float num85 = 1f;
num85 += (float)num34 * 0.1f;
num85 += (float)num10 * 0.15f;
num85 += (float)num42 * 0.075f;
num85 += (float)num47 * 0.5f;
if (flag5)
{
num85 += 0.5f;
}
num85 += (float)GetBuffCount(RoR2Content.Buffs.AttackSpeedOnCrit) * 0.12f;
if (HasBuff(RoR2Content.Buffs.Warbanner))
{
num85 += 0.3f;
}
if (HasBuff(RoR2Content.Buffs.Energized))
{
num85 += 0.7f;
}
if (HasBuff(RoR2Content.Buffs.WarCryBuff) || HasBuff(RoR2Content.Buffs.TeamWarCry))
{
num85 += 1f;
}
num85 += (float)num31 * 0.1f;
num85 += (float)buffCount2 * 0.07f;
num85 /= (float)(num44 + 1);
num85 = Mathf.Max(num85, 0.1f);
num84 *= num85;
if (buffCount > 0)
{
num84 *= 1f - 0.05f * (float)buffCount;
}
if (tamperedHeartActive)
{
num84 += num84 * tamperedHeartAttackSpeedBonus;
}
attackSpeed = num84;
critMultiplier = 2f + 1f * (float)num43;
float num86 = baseCrit + levelCrit * num56;
num86 += (float)num11 * 10f;
if (num12 > 0)
{
num86 += 5f;
}
if (num35 > 0)
{
num86 += 5f;
}
if (num13 > 0)
{
num86 += 5f;
}
if (num14 > 0)
{
num86 += 5f;
}
if (num19 > 0)
{
num86 += 5f;
}
if (HasBuff(RoR2Content.Buffs.FullCrit))
{
num86 += 100f;
}
num86 += (float)num31 * 10f;
num86 += (float)buffCount2 * 7f;
if (num46 == 0)
{
crit = num86;
}
else
{
critMultiplier += num86 * 0.01f;
crit = 0f;
}
armor = baseArmor + levelArmor * num56;
armor *= 1f + 0.1f * (float)num31;
armor *= 1f + 0.07f * (float)buffCount2;
armor += (float)num26 * 70f;
armor += (HasBuff(RoR2Content.Buffs.ArmorBoost) ? 200f : 0f);
armor += (HasBuff(RoR2Content.Buffs.SmallArmorBoost) ? 100f : 0f);
armor += (HasBuff(DLC1Content.Buffs.OutOfCombatArmorBuff) ? (100f * (float)num50) : 0f);
armor += (HasBuff(RoR2Content.Buffs.ElephantArmorBoost) ? 500f : 0f);
armor += (HasBuff(DLC1Content.Buffs.VoidSurvivorCorruptMode) ? 100f : 0f);
armor += (HasBuff(DLC2Content.Buffs.AurelioniteBlessing) ? (60f + 0.1f * (float)master.money) : 0f);
if (HasBuff(RoR2Content.Buffs.Cripple))
{
armor -= 20f;
}
if (HasBuff(RoR2Content.Buffs.Pulverized))
{
armor -= 60f;
}
if (isSprinting && num23 > 0)
{
armor += num23 * 30;
}
if (tamperedHeartActive)
{
armor += tamperedHeartArmorBonus;
}
int buffCount4 = GetBuffCount(DLC1Content.Buffs.PermanentDebuff);
armor -= (float)buffCount4 * 2f;
float num87 = 0f;
if (num36 > 0)
{
num87 += 2f + 1f * (float)(num36 - 1);
}
float num88 = 1f;
if (HasBuff(JunkContent.Buffs.GoldEmpowered))
{
num88 *= 0.25f;
}
for (int i = 0; i < num16; i++)
{
num88 *= 0.75f;
}
for (int j = 0; j < num44; j++)
{
num88 *= 0.5f;
}
for (int k = 0; k < num47; k++)
{
num88 *= 0.5f;
}
if (teamComponent.teamIndex == TeamIndex.Monster && Run.instance.selectedDifficulty >= DifficultyIndex.Eclipse7)
{
num88 *= 0.5f;
}
if (HasBuff(RoR2Content.Buffs.NoCooldowns))
{
num88 = 0f;
}
if ((bool)skillLocator.primary)
{
skillLocator.primary.cooldownScale = num88;
skillLocator.primary.flatCooldownReduction = num87;
}
if ((bool)skillLocator.secondaryBonusStockSkill)
{
skillLocator.secondaryBonusStockSkill.cooldownScale = num88;
skillLocator.secondaryBonusStockSkill.SetBonusStockFromBody(num21 + extraSecondaryFromSkill);
skillLocator.secondaryBonusStockSkill.flatCooldownReduction = num87;
}
if ((bool)skillLocator.utilityBonusStockSkill)
{
float num89 = num88;
if (num24 > 0)
{
num89 *= 2f / 3f;
}
skillLocator.utilityBonusStockSkill.cooldownScale = num89;
skillLocator.utilityBonusStockSkill.flatCooldownReduction = num87;
skillLocator.utilityBonusStockSkill.SetBonusStockFromBody(num24 * 2);
}
if ((bool)skillLocator.specialBonusStockSkill)
{
skillLocator.specialBonusStockSkill.cooldownScale = num88;
if (num22 > 0)
{
skillLocator.specialBonusStockSkill.cooldownScale *= 0.67f;
}
skillLocator.specialBonusStockSkill.flatCooldownReduction = num87;
skillLocator.specialBonusStockSkill.SetBonusStockFromBody(num22 + extraSpecialFromSkill);
}
critHeal = 0f;
if (num19 > 0)
{
float num90 = crit;
crit /= num19 + 1;
critHeal = num90 - crit;
}
cursePenalty = 1f;
if (num28 > 0)
{
cursePenalty = Mathf.Pow(2f, num28);
}
if (flag4)
{
cursePenalty *= 10f;
}
int buffCount5 = GetBuffCount(RoR2Content.Buffs.PermanentCurse);
if (buffCount5 > 0)
{
cursePenalty += (float)buffCount5 * 0.01f;
}
if (HasBuff(RoR2Content.Buffs.Weak))
{
armor -= 30f;
damage *= 0.6f;
moveSpeed *= 0.6f;
}
if (HasBuff(DLC2Content.Buffs.lunarruin))
{
moveSpeed *= 0.8f;
}
if (flag)
{
maxHealth *= 1.5f;
maxShield *= 1.5f;
attackSpeed *= 1.7f;
moveSpeed *= 1.3f;
armor += 20f;
damage *= 2f;
regen *= 4f;
}
if (HasBuff(DLC2Content.Buffs.BoostAllStatsBuff))
{
float num91 = (float)num53 * boostAllStatsMultiplier;
_ = maxHealth;
_ = moveSpeed;
_ = damage;
_ = attackSpeed;
_ = crit;
_ = regen;
maxHealth += maxHealth * num91;
moveSpeed += moveSpeed * num91;
damage += damage * num91;
attackSpeed += attackSpeed * num91;
crit += crit * num91;
regen += regen * num91;
}
maxBonusHealth = maxHealth;
if (num27 > 0 && !flag)
{
float num92 = Mathf.Pow(0.95f, num27);
attackSpeed *= num92;
moveSpeed *= num92;
damage *= num92;
regen *= num92;
cursePenalty += 0.1f * (float)num27;
}
if (HasBuff(DLC2Content.Buffs.SoulCost))
{
cursePenalty += 0.1f * (float)GetBuffCount(DLC2Content.Buffs.SoulCost);
}
maxHealth /= cursePenalty;
maxShield /= cursePenalty;
oneShotProtectionFraction = Mathf.Max(0f, oneShotProtectionFraction - (1f - 1f / cursePenalty));
maxBarrier = maxHealth + maxShield;
barrierDecayRate = maxBarrier / 30f;
if (NetworkServer.active)
{
float num93 = maxHealth - num59;
float num94 = maxShield - num60;
if (num93 > 0f)
{
healthComponent.Heal(num93, default(ProcChainMask), nonRegen: false);
}
else if (healthComponent.health > maxHealth)
{
healthComponent.Networkhealth = Mathf.Max(healthComponent.health + num93, maxHealth);
}
if (num94 > 0f)
{
healthComponent.RechargeShield(num94);
}
else if (healthComponent.shield > maxShield)
{
healthComponent.Networkshield = Mathf.Max(healthComponent.shield + num94, maxShield);
}
}
bleedChance = 10f * (float)num41;
visionDistance = baseVisionDistance;
if (HasBuff(DLC1Content.Buffs.Blinded))
{
visionDistance = Mathf.Min(visionDistance, 15f);
}
if (level != num)
{
OnCalculatedLevelChanged(num, level);
}
int num95 = 0;
if (num53 > 0 && !HasBuff(DLC2Content.Buffs.BoostAllStatsBuff))
{
BuffIndex[] nonHiddenBuffIndices = BuffCatalog.nonHiddenBuffIndices;
foreach (BuffIndex buffIndex in nonHiddenBuffIndices)
{
if (HasBuff(buffIndex) && buffIndex != DLC2Content.Buffs.BoostAllStatsBuff.buffIndex && !BuffCatalog.ignoreGrowthNectarIndices.Contains(buffIndex))
{
num95++;
if (num95 >= 5 && !HasBuff(DLC2Content.Buffs.BoostAllStatsBuff))
{
AddTimedBuff(DLC2Content.Buffs.BoostAllStatsBuff, 5f);
}
}
}
}
UpdateAllTemporaryVisualEffects();
statsDirty = false;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void HandleDisableAllSkillsDebuff()
{
bool flag = HasBuff(DLC2Content.Buffs.DisableAllSkills);
if (flag != allSkillsDisabled)
{
if (flag)
{
HandleSkillDisableState(_disable: true);
allSkillsDisabled = true;
}
else
{
HandleSkillDisableState(_disable: false);
allSkillsDisabled = false;
}
}
void HandleSkillDisableState(bool _disable)
{
if (base.hasAuthority)
{
SkillDef skillDef = LegacyResourcesAPI.Load<SkillDef>("Skills/DisabledSkills");
if (!skillDef)
{
Debug.LogWarning("Could not find disabledSkill for DisableAllSkills.");
}
else if (_disable)
{
skillLocator.primary.SetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Contextual);
skillLocator.secondary.SetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Contextual);
skillLocator.utility.SetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Contextual);
skillLocator.special.SetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Contextual);
inventory.SetEquipmentDisabled(_active: true);
Util.PlaySound("Play_env_meridian_primeDevestator_debuff", base.gameObject);
screenDamageSkillsDisabled = new ScreenDamageCalculatorDisabledSkills();
healthComponent.screenDamageCalculator = screenDamageSkillsDisabled;
}
else
{
skillLocator.primary.UnsetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Contextual);
skillLocator.secondary.UnsetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Contextual);
skillLocator.utility.UnsetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Contextual);
skillLocator.special.UnsetSkillOverride(this, skillDef, GenericSkill.SkillOverridePriority.Contextual);
inventory.SetEquipmentDisabled(_active: false);
if (screenDamageSkillsDisabled != null)
{
if (healthComponent.screenDamageCalculator == screenDamageSkillsDisabled)
{
healthComponent.screenDamageCalculator = null;
}
screenDamageSkillsDisabled.End();
}
}
}
}
}
public void OnTeamLevelChanged()
{
statsDirty = true;
}
private void OnCalculatedLevelChanged(float oldLevel, float newLevel)
{
if (newLevel > oldLevel)
{
int num = Mathf.FloorToInt(oldLevel);
if (Mathf.FloorToInt(newLevel) > num && num != 0)
{
OnLevelUp();
}
}
}
private void OnLevelUp()
{
GlobalEventManager.OnCharacterLevelUp(this);
if (inventory.GetItemCount(DLC2Content.Items.OnLevelUpFreeUnlock) > 0)
{
solitudeLevelCount++;
AddFreeChestBuff();
Util.PlaySound("Play_item_proc_onLevelUpFreeUnlock_activate", base.gameObject);
}
}
public void SetAimTimer(float duration)
{
aimTimer = duration;
}
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
byte num = reader.ReadByte();
if (((uint)num & (true ? 1u : 0u)) != 0)
{
NetworkInstanceId networkInstanceId = reader.ReadNetworkId();
if (networkInstanceId != masterObjectId)
{
masterObjectId = networkInstanceId;
statsDirty = true;
}
}
if ((num & 2u) != 0)
{
ReadBuffs(reader);
}
if ((num & 4u) != 0)
{
bool flag = reader.ReadBoolean();
if (!hasEffectiveAuthority && flag != outOfCombat)
{
outOfCombat = flag;
statsDirty = true;
}
}
if ((num & 8u) != 0)
{
bool flag2 = reader.ReadBoolean();
if (flag2 != outOfDanger)
{
outOfDanger = flag2;
statsDirty = true;
}
}
if ((num & 0x10u) != 0)
{
bool flag3 = reader.ReadBoolean();
if (flag3 != isSprinting && !hasEffectiveAuthority)
{
statsDirty = true;
isSprinting = flag3;
}
}
}
public override bool OnSerialize(NetworkWriter writer, bool initialState)
{
uint num = base.syncVarDirtyBits;
if (initialState)
{
num = 31u;
}
bool num2 = (num & 1) != 0;
bool flag = (num & 2) != 0;
bool flag2 = (num & 4) != 0;
bool flag3 = (num & 8) != 0;
bool flag4 = (num & 0x10) != 0;
writer.Write((byte)num);
if (num2)
{
writer.Write(masterObjectId);
}
if (flag)
{
WriteBuffs(writer);
}
if (flag2)
{
writer.Write(outOfCombat);
}
if (flag3)
{
writer.Write(outOfDanger);
}
if (flag4)
{
writer.Write(isSprinting);
}
if (!initialState)
{
return num != 0;
}
return false;
}
public void TransmitItemBehavior(NetworkItemBehaviorData itemBehaviorData)
{
if (!NetworkServer.active)
{
InternalTransmitItemBehavior(itemBehaviorData);
CallCmdTransmitItemBehavior(itemBehaviorData);
}
else
{
ServerTransmitItemBehavior(itemBehaviorData);
}
}
[Server]
private void ServerTransmitItemBehavior(NetworkItemBehaviorData itemBehaviorData)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::ServerTransmitItemBehavior(RoR2.CharacterBody/NetworkItemBehaviorData)' called on client");
return;
}
CallRpcTransmitItemBehavior(itemBehaviorData);
InternalTransmitItemBehavior(itemBehaviorData);
}
[Command]
private void CmdTransmitItemBehavior(NetworkItemBehaviorData itemBehaviorData)
{
ServerTransmitItemBehavior(itemBehaviorData);
}
[ClientRpc(channel = 1)]
private void RpcTransmitItemBehavior(NetworkItemBehaviorData itemBehaviorData)
{
if (!NetworkServer.active)
{
InternalTransmitItemBehavior(itemBehaviorData);
}
}
private void InternalTransmitItemBehavior(NetworkItemBehaviorData itemBehaviorData)
{
OnNetworkItemBehaviorUpdate?.Invoke(itemBehaviorData);
}
public T AddItemBehavior<T>(int stack) where T : ItemBehavior
{
T val = GetComponent<T>();
if (stack > 0)
{
if (!val)
{
val = base.gameObject.AddComponent<T>();
val.body = this;
val.enabled = true;
}
val.stack = stack;
return val;
}
if ((bool)val)
{
UnityEngine.Object.Destroy(val);
}
return null;
}
public void HandleOnKillEffectsServer(DamageReport damageReport)
{
int num = killCountServer + 1;
killCountServer = num;
AddMultiKill(1);
}
public void OnKilledOtherServer(DamageReport damageReport)
{
}
public void AddHelfireDuration(float duration)
{
helfireLifetime = duration;
}
[Server]
private void UpdateHelfire(float deltaTime)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::UpdateHelfire(System.Single)' called on client");
return;
}
helfireLifetime -= deltaTime;
bool flag = false;
if ((bool)inventory)
{
flag = itemAvailability.helfireCount > 0 || helfireLifetime > 0f;
}
if ((bool)helfireController != flag)
{
if (flag)
{
helfireController = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/HelfireController")).GetComponent<HelfireController>();
helfireController.networkedBodyAttachment.AttachToGameObjectAndSpawn(base.gameObject);
}
else
{
UnityEngine.Object.Destroy(helfireController.gameObject);
helfireController = null;
}
}
}
private void UpdateFireTrail()
{
bool hasFireTrail = itemAvailability.hasFireTrail;
if (hasFireTrail != (bool)fireTrail)
{
if (hasFireTrail)
{
fireTrail = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/FireTrail"), transform).GetComponent<DamageTrail>();
fireTrail.transform.position = footPosition;
fireTrail.owner = base.gameObject;
fireTrail.radius *= radius;
}
else
{
UnityEngine.Object.Destroy(fireTrail.gameObject);
fireTrail = null;
}
}
if ((bool)fireTrail)
{
fireTrail.damagePerSecond = damage * 1.5f;
}
}
private void UpdateAffixPoison(float deltaTime)
{
if (!itemAvailability.hasAffixPoison)
{
return;
}
poisonballTimer += deltaTime;
if (poisonballTimer >= 6f)
{
int num = 3 + (int)radius;
poisonballTimer = 0f;
Vector3 up = Vector3.up;
float num2 = 360f / (float)num;
Vector3 normalized = Vector3.ProjectOnPlane(transform.forward, up).normalized;
Vector3 vector = Vector3.RotateTowards(up, normalized, 0.43633232f, float.PositiveInfinity);
for (int i = 0; i < num; i++)
{
Vector3 forward = Quaternion.AngleAxis(num2 * (float)i, up) * vector;
ProjectileManager.instance.FireProjectile(LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/PoisonOrbProjectile"), corePosition, Util.QuaternionSafeLookRotation(forward), base.gameObject, damage * 1f, 0f, Util.CheckRoll(crit, master));
}
}
}
private void UpdateAffixLunar(float deltaTime)
{
if (!outOfCombat && itemAvailability.hasAffixLunar)
{
lunarMissileRechargeTimer += deltaTime;
lunarMissileTimerBetweenShots += deltaTime;
int num = 4;
if (!lunarMissilePrefab)
{
lunarMissilePrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/LunarMissileProjectile");
}
if (lunarMissileRechargeTimer >= 10f)
{
lunarMissileRechargeTimer = 0f;
remainingMissilesToFire += num;
}
if (remainingMissilesToFire > 0 && lunarMissileTimerBetweenShots > 0.1f)
{
lunarMissileTimerBetweenShots = 0f;
Vector3 vector = (inputBank ? inputBank.aimDirection : transform.forward);
float num2 = 180f / (float)num;
float num3 = 3f + (float)(int)radius * 1f;
float num4 = damage * 0.3f;
Quaternion rotation = Util.QuaternionSafeLookRotation(vector);
Vector3 vector2 = Quaternion.AngleAxis((float)(remainingMissilesToFire - 1) * num2 - num2 * (float)(num - 1) / 2f, vector) * Vector3.up * num3;
Vector3 position = aimOrigin + vector2;
FireProjectileInfo fireProjectileInfo = default(FireProjectileInfo);
fireProjectileInfo.projectilePrefab = lunarMissilePrefab;
fireProjectileInfo.position = position;
fireProjectileInfo.rotation = rotation;
fireProjectileInfo.owner = base.gameObject;
fireProjectileInfo.damage = num4;
fireProjectileInfo.crit = Util.CheckRoll(crit, master);
fireProjectileInfo.force = 200f;
FireProjectileInfo fireProjectileInfo2 = fireProjectileInfo;
ProjectileManager.instance.FireProjectile(fireProjectileInfo2);
remainingMissilesToFire--;
}
}
}
private void UpdateAllTemporaryVisualEffects()
{
int buffCount = GetBuffCount(RoR2Content.Buffs.NullifyStack);
UpdateSingleTemporaryVisualEffect(ref engiShieldTempEffectInstance, AssetReferences.engiShieldTempEffectPrefab, bestFitRadius, healthComponent.shield > 0f && HasBuff(RoR2Content.Buffs.EngiShield));
ref TemporaryVisualEffect tempEffect = ref bucklerShieldTempEffectInstance;
GameObject bucklerShieldTempEffectPrefab = AssetReferences.bucklerShieldTempEffectPrefab;
float effectRadius = radius;
int active;
if (isSprinting)
{
Inventory obj = inventory;
active = (((object)obj != null && obj.GetItemCount(RoR2Content.Items.SprintArmor) > 0) ? 1 : 0);
}
else
{
active = 0;
}
UpdateSingleTemporaryVisualEffect(ref tempEffect, bucklerShieldTempEffectPrefab, effectRadius, (byte)active != 0);
UpdateSingleTemporaryVisualEffect(ref slowDownTimeTempEffectInstance, AssetReferences.slowDownTimeTempEffectPrefab, radius, HasBuff(RoR2Content.Buffs.Slow60));
UpdateSingleTemporaryVisualEffect(ref crippleEffectInstance, AssetReferences.crippleEffectPrefab, radius, HasBuff(RoR2Content.Buffs.Cripple));
UpdateSingleTemporaryVisualEffect(ref tonicBuffEffectInstance, AssetReferences.tonicBuffEffectPrefab, radius, HasBuff(RoR2Content.Buffs.TonicBuff));
UpdateSingleTemporaryVisualEffect(ref weakTempEffectInstance, AssetReferences.weakTempEffectPrefab, radius, HasBuff(RoR2Content.Buffs.Weak));
UpdateSingleTemporaryVisualEffect(ref energizedTempEffectInstance, AssetReferences.energizedTempEffectPrefab, radius, HasBuff(RoR2Content.Buffs.Energized));
UpdateSingleTemporaryVisualEffect(ref barrierTempEffectInstance, AssetReferences.barrierTempEffectPrefab, bestFitRadius, healthComponent.barrier > 0f);
UpdateSingleTemporaryVisualEffect(ref regenBoostEffectInstance, AssetReferences.regenBoostEffectPrefab, bestFitRadius, HasBuff(JunkContent.Buffs.MeatRegenBoost));
UpdateSingleTemporaryVisualEffect(ref elephantDefenseEffectInstance, AssetReferences.elephantDefenseEffectPrefab, radius, HasBuff(RoR2Content.Buffs.ElephantArmorBoost));
UpdateSingleTemporaryVisualEffect(ref healingDisabledEffectInstance, AssetReferences.healingDisabledEffectPrefab, radius, HasBuff(RoR2Content.Buffs.HealingDisabled));
UpdateSingleTemporaryVisualEffect(ref noCooldownEffectInstance, AssetReferences.noCooldownEffectPrefab, radius, HasBuff(RoR2Content.Buffs.NoCooldowns), "Head");
ref TemporaryVisualEffect tempEffect2 = ref doppelgangerEffectInstance;
GameObject doppelgangerEffectPrefab = AssetReferences.doppelgangerEffectPrefab;
float effectRadius2 = radius;
Inventory obj2 = inventory;
UpdateSingleTemporaryVisualEffect(ref tempEffect2, doppelgangerEffectPrefab, effectRadius2, (object)obj2 != null && obj2.GetItemCount(RoR2Content.Items.InvadingDoppelganger) > 0, "Head");
UpdateSingleTemporaryVisualEffect(ref nullifyStack1EffectInstance, AssetReferences.nullifyStack1EffectPrefab, radius, buffCount == 1);
UpdateSingleTemporaryVisualEffect(ref nullifyStack2EffectInstance, AssetReferences.nullifyStack2EffectPrefab, radius, buffCount == 2);
UpdateSingleTemporaryVisualEffect(ref nullifyStack3EffectInstance, AssetReferences.nullifyStack3EffectPrefab, radius, HasBuff(RoR2Content.Buffs.Nullified));
UpdateSingleTemporaryVisualEffect(ref deathmarkEffectInstance, AssetReferences.deathmarkEffectPrefab, radius, HasBuff(RoR2Content.Buffs.DeathMark));
UpdateSingleTemporaryVisualEffect(ref crocoRegenEffectInstance, AssetReferences.crocoRegenEffectPrefab, bestFitRadius, HasBuff(RoR2Content.Buffs.CrocoRegen));
UpdateSingleTemporaryVisualEffect(ref mercExposeEffectInstance, AssetReferences.mercExposeEffectPrefab, radius, HasBuff(RoR2Content.Buffs.MercExpose));
UpdateSingleTemporaryVisualEffect(ref lifestealOnHitEffectInstance, AssetReferences.lifestealOnHitEffectPrefab, bestFitRadius, HasBuff(RoR2Content.Buffs.LifeSteal));
UpdateSingleTemporaryVisualEffect(ref teamWarCryEffectInstance, AssetReferences.teamWarCryEffectPrefab, bestFitRadius, HasBuff(RoR2Content.Buffs.TeamWarCry), "HeadCenter");
UpdateSingleTemporaryVisualEffect(ref lunarGolemShieldEffectInstance, AssetReferences.lunarGolemShieldEffectPrefab, bestFitRadius, HasBuff(RoR2Content.Buffs.LunarShell));
UpdateSingleTemporaryVisualEffect(ref randomDamageEffectInstance, AssetReferences.randomDamageEffectPrefab, radius, HasBuff(RoR2Content.Buffs.PowerBuff));
UpdateSingleTemporaryVisualEffect(ref warbannerEffectInstance, AssetReferences.warbannerEffectPrefab, radius, HasBuff(RoR2Content.Buffs.Warbanner));
UpdateSingleTemporaryVisualEffect(ref teslaFieldEffectInstance, AssetReferences.teslaFieldEffectPrefab, bestFitRadius, HasBuff(RoR2Content.Buffs.TeslaField));
UpdateSingleTemporaryVisualEffect(ref lunarSecondaryRootEffectInstance, AssetReferences.lunarSecondaryRootEffectPrefab, radius, HasBuff(RoR2Content.Buffs.LunarSecondaryRoot));
UpdateSingleTemporaryVisualEffect(ref lunarDetonatorEffectInstance, AssetReferences.lunarDetonatorEffectPrefab, radius, HasBuff(RoR2Content.Buffs.LunarDetonationCharge));
UpdateSingleTemporaryVisualEffect(ref fruitingEffectInstance, AssetReferences.fruitingEffectPrefab, radius, HasBuff(RoR2Content.Buffs.Fruiting));
UpdateSingleTemporaryVisualEffect(ref mushroomVoidTempEffectInstance, AssetReferences.mushroomVoidTempEffectPrefab, radius, HasBuff(DLC1Content.Buffs.MushroomVoidActive));
UpdateSingleTemporaryVisualEffect(ref bearVoidTempEffectInstance, AssetReferences.bearVoidTempEffectPrefab, radius, HasBuff(DLC1Content.Buffs.BearVoidReady));
UpdateSingleTemporaryVisualEffect(ref outOfCombatArmorEffectInstance, AssetReferences.outOfCombatArmorEffectPrefab, radius, HasBuff(DLC1Content.Buffs.OutOfCombatArmorBuff));
UpdateSingleTemporaryVisualEffect(ref voidFogMildEffectInstance, AssetReferences.voidFogMildEffectPrefab, radius, HasBuff(RoR2Content.Buffs.VoidFogMild));
UpdateSingleTemporaryVisualEffect(ref voidFogStrongEffectInstance, AssetReferences.voidFogStrongEffectPrefab, radius, HasBuff(RoR2Content.Buffs.VoidFogStrong));
UpdateSingleTemporaryVisualEffect(ref voidRaidcrabWardWipeFogEffectInstance, AssetReferences.voidRaidcrabWardWipeFogEffectPrefab, radius, HasBuff(DLC1Content.Buffs.VoidRaidCrabWardWipeFog));
UpdateSingleTemporaryVisualEffect(ref voidJailerSlowEffectInstance, AssetReferences.voidJailerSlowEffectPrefab, radius, HasBuff(DLC1Content.Buffs.JailerSlow));
UpdateSingleTemporaryVisualEffect(ref aurelioniteBlessingEffectInstance, AssetReferences.aurelioniteBlessingEffectInstance, bestFitActualRadius, HasBuff(DLC2Content.Buffs.AurelioniteBlessing), "Pelvis");
if ((bool)mushroomVoidTempEffectInstance && !HasBuff(DLC1Content.Buffs.MushroomVoidActive))
{
UnityEngine.Object.Destroy(mushroomVoidTempEffectInstance.gameObject);
}
}
private void UpdateSingleTemporaryVisualEffect(ref TemporaryVisualEffect tempEffect, string resourceString, float effectRadius, bool active, string childLocatorOverride = "")
{
bool flag = tempEffect != null;
if (flag == active)
{
return;
}
if (active)
{
if (flag)
{
return;
}
GameObject gameObject = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>(resourceString), corePosition, Quaternion.identity);
tempEffect = gameObject.GetComponent<TemporaryVisualEffect>();
tempEffect.parentTransform = coreTransform;
tempEffect.visualState = TemporaryVisualEffect.VisualState.Enter;
tempEffect.healthComponent = healthComponent;
tempEffect.radius = effectRadius;
LocalCameraEffect component = gameObject.GetComponent<LocalCameraEffect>();
if ((bool)component)
{
component.targetCharacter = base.gameObject;
}
if (string.IsNullOrEmpty(childLocatorOverride))
{
return;
}
ChildLocator childLocator = modelLocator?.modelTransform?.GetComponent<ChildLocator>();
if ((bool)childLocator)
{
Transform transform = childLocator.FindChild(childLocatorOverride);
if ((bool)transform)
{
tempEffect.parentTransform = transform;
}
}
}
else if ((bool)tempEffect)
{
tempEffect.visualState = TemporaryVisualEffect.VisualState.Exit;
}
}
private void UpdateSingleTemporaryVisualEffect(ref TemporaryVisualEffect tempEffect, GameObject tempEffectPrefab, float effectRadius, bool active, string childLocatorOverride = "")
{
bool flag = tempEffect != null;
if (flag == active)
{
return;
}
if (active)
{
if (flag)
{
return;
}
if ((bool)tempEffectPrefab)
{
GameObject gameObject = UnityEngine.Object.Instantiate(tempEffectPrefab, corePosition, Quaternion.identity);
tempEffect = gameObject.GetComponent<TemporaryVisualEffect>();
tempEffect.parentTransform = coreTransform;
tempEffect.visualState = TemporaryVisualEffect.VisualState.Enter;
tempEffect.healthComponent = healthComponent;
tempEffect.radius = effectRadius;
LocalCameraEffect component = gameObject.GetComponent<LocalCameraEffect>();
if ((bool)component)
{
component.targetCharacter = base.gameObject;
}
if (string.IsNullOrEmpty(childLocatorOverride))
{
return;
}
ChildLocator childLocator = modelLocator?.modelTransform?.GetComponent<ChildLocator>();
if ((bool)childLocator)
{
Transform transform = childLocator.FindChild(childLocatorOverride);
if ((bool)transform)
{
tempEffect.parentTransform = transform;
}
}
}
else
{
Debug.LogError("Can't instantiate null temporary visual effect");
}
}
else if ((bool)tempEffect)
{
tempEffect.visualState = TemporaryVisualEffect.VisualState.Exit;
}
}
public VisibilityLevel GetVisibilityLevel(CharacterBody observer)
{
return GetVisibilityLevel(observer ? observer.teamComponent.teamIndex : TeamIndex.None);
}
public VisibilityLevel GetVisibilityLevel(TeamIndex observerTeam)
{
if (!hasCloakBuff)
{
return VisibilityLevel.Visible;
}
if (teamComponent.teamIndex != observerTeam)
{
return VisibilityLevel.Cloaked;
}
return VisibilityLevel.Revealed;
}
public void AddSpreadBloom(float value)
{
spreadBloomInternal = Mathf.Min(spreadBloomInternal + value, 1f);
}
public void SetSpreadBloom(float value, bool canOnlyIncreaseBloom = true)
{
if (canOnlyIncreaseBloom)
{
spreadBloomInternal = Mathf.Clamp(value, spreadBloomInternal, 1f);
}
else
{
spreadBloomInternal = Mathf.Min(value, 1f);
}
}
private void UpdateSpreadBloom(float dt)
{
float num = 1f / spreadBloomDecayTime;
spreadBloomInternal = Mathf.Max(spreadBloomInternal - num * dt, 0f);
}
[Client]
public void SendConstructTurret(CharacterBody builder, Vector3 position, Quaternion rotation, MasterCatalog.MasterIndex masterIndex)
{
if (!NetworkClient.active)
{
Debug.LogWarning("[Client] function 'System.Void RoR2.CharacterBody::SendConstructTurret(RoR2.CharacterBody,UnityEngine.Vector3,UnityEngine.Quaternion,RoR2.MasterCatalog/MasterIndex)' called on server");
return;
}
ConstructTurretMessage msg = new ConstructTurretMessage
{
builder = builder.gameObject,
position = position,
rotation = rotation,
turretMasterIndex = masterIndex
};
ClientScene.readyConnection.Send(62, msg);
}
[NetworkMessageHandler(msgType = 62, server = true)]
private static void HandleConstructTurret(NetworkMessage netMsg)
{
ConstructTurretMessage constructTurretMessage = netMsg.ReadMessage<ConstructTurretMessage>();
if (!constructTurretMessage.builder)
{
return;
}
CharacterBody component = constructTurretMessage.builder.GetComponent<CharacterBody>();
if ((bool)component)
{
CharacterMaster characterMaster = component.master;
if ((bool)characterMaster)
{
CharacterMaster characterMaster2 = new MasterSummon
{
masterPrefab = MasterCatalog.GetMasterPrefab(constructTurretMessage.turretMasterIndex),
position = constructTurretMessage.position,
rotation = constructTurretMessage.rotation,
summonerBodyObject = component.gameObject,
ignoreTeamMemberLimit = true,
inventoryToCopy = characterMaster.inventory
}.Perform();
Deployable deployable = characterMaster2.gameObject.AddComponent<Deployable>();
deployable.onUndeploy = new UnityEvent();
deployable.onUndeploy.AddListener(characterMaster2.TrueKill);
characterMaster.AddDeployable(deployable, DeployableSlot.EngiTurret);
}
}
}
public void AddIncreasedDamageMultiKillTime()
{
increasedDamageKillTimer = 5f;
}
[Server]
public void AddMultiKill(int kills)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::AddMultiKill(System.Int32)' called on client");
return;
}
multiKillTimer = 1f;
multiKillCount += kills;
int num = (inventory ? inventory.GetItemCount(RoR2Content.Items.WarCryOnMultiKill) : 0);
if (num > 0 && multiKillCount >= 4)
{
AddTimedBuff(RoR2Content.Buffs.WarCryBuff, 2f + 4f * (float)num);
}
increasedDamageKillTimer = 5f;
increasedDamageKillCount += kills;
increasedDamageKillCountBuff += kills;
if ((((bool)inventory && inventory.GetItemCount(DLC2Content.Items.IncreaseDamageOnMultiKill) != 0) ? 1 : 0) > (false ? 1 : 0))
{
if (increasedDamageKillCountBuff >= 5)
{
AddBuff(DLC2Content.Buffs.IncreaseDamageBuff);
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/IncreaseDamageOnMultiKillVFX"), new EffectData
{
origin = base.gameObject.transform.position
}, transmit: true);
increasedDamageKillCountBuff = 0;
}
if (increasedDamageKillCount > oldKillcount)
{
oldKillcount = increasedDamageKillCount;
}
}
}
[Server]
private void UpdateMultiKill(float deltaTime)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::UpdateMultiKill(System.Single)' called on client");
return;
}
multiKillTimer -= deltaTime;
if (multiKillTimer <= 0f)
{
multiKillTimer = 0f;
multiKillCount = 0;
}
increasedDamageKillTimer -= deltaTime;
if (increasedDamageKillTimer <= 0f)
{
increasedDamageKillTimer = 0f;
increasedDamageKillCount = 0;
increasedDamageKillCountBuff = 0;
oldKillcount = 0;
oldComboMeter = 0;
if (HasBuff(DLC2Content.Buffs.IncreaseDamageBuff))
{
RemoveBuff(DLC2Content.Buffs.IncreaseDamageBuff);
}
}
}
public void AddIncreasePrimaryDamageStack()
{
int buffCount = GetBuffCount(DLC2Content.Buffs.IncreasePrimaryDamageBuff);
int itemCount = inventory.GetItemCount(DLC2Content.Items.IncreasePrimaryDamage);
int num = 4 + itemCount;
if (buffCount < num)
{
AddBuff(DLC2Content.Buffs.IncreasePrimaryDamageBuff);
}
buffCount = GetBuffCount(DLC2Content.Buffs.IncreasePrimaryDamageBuff);
TransmitItemBehavior(new NetworkItemBehaviorData(DLC2Content.Items.IncreasePrimaryDamage.itemIndex, buffCount));
float num2 = baseDamage + levelDamage * (level - 1f);
luminousShotDamage = num2 * (1.25f + 0.25f * (float)itemCount) * (float)buffCount;
}
public void IncreasePrimaryDamageReset()
{
if (GetBuffCount(DLC2Content.Buffs.IncreasePrimaryDamageBuff) > 0)
{
SetBuffCount(DLC2Content.Buffs.IncreasePrimaryDamageBuff.buffIndex, 0);
TransmitItemBehavior(new NetworkItemBehaviorData(DLC2Content.Items.IncreasePrimaryDamage.itemIndex, 0f));
}
luminousShotReady = false;
}
[Server]
private void UpdateDelayedDamage(float deltaTime)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::UpdateDelayedDamage(System.Single)' called on client");
return;
}
int num = (inventory ? inventory.GetItemCount(DLC2Content.Items.DelayedDamage) : 0);
if (num > 0)
{
int buffCount = GetBuffCount(DLC2Content.Buffs.DelayedDamageBuff);
if (oldDelayedDamageCount < num)
{
int num2 = num - oldDelayedDamageCount;
for (int i = 0; i < num2; i++)
{
AddBuff(DLC2Content.Buffs.DelayedDamageBuff);
}
oldDelayedDamageCount = num;
}
else if (oldDelayedDamageCount > num)
{
oldDelayedDamageCount = num;
}
if (buffCount < num)
{
delayedDamageRefreshTime -= deltaTime;
if (delayedDamageRefreshTime <= 0f)
{
AddBuff(DLC2Content.Buffs.DelayedDamageBuff);
delayedDamageRefreshTime = 10f;
}
}
}
else
{
delayedDamageRefreshTime = 10f;
oldDelayedDamageCount = 0;
RemoveBuff(DLC2Content.Buffs.DelayedDamageBuff);
RemoveBuff(DLC2Content.Buffs.DelayedDamageDebuff);
RemoveOldestTimedBuff(DLC2Content.Buffs.DelayedDamageDebuff);
}
}
public void SpawnDelayedDamageEffect()
{
if (NetworkServer.active)
{
ServerSpawnDelayedDamageEffect();
}
else
{
CallCmdSpawnDelayedDamageEffect();
}
}
[Server]
private void ServerSpawnDelayedDamageEffect()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::ServerSpawnDelayedDamageEffect()' called on client");
}
else
{
UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/DelayedDamageIndicator"), mainHurtBox ? mainHurtBox.transform.position : transform.position, Quaternion.identity, mainHurtBox ? mainHurtBox.transform : transform);
}
}
[Command]
private void CmdSpawnDelayedDamageEffect()
{
ServerSpawnDelayedDamageEffect();
}
public void SecondHalfOfDelayedDamage(DamageInfo halfDamage)
{
RemoveBuff(DLC2Content.Buffs.DelayedDamageBuff);
AddBuff(DLC2Content.Buffs.DelayedDamageDebuff);
TransmitItemBehavior(new NetworkItemBehaviorData(DLC2Content.Items.DelayedDamage.itemIndex, 0f));
DelayedDamageInfo delayedDamageInfo = new DelayedDamageInfo();
delayedDamageInfo.halfDamage = halfDamage;
incomingDamageList.Add(delayedDamageInfo);
if (incomingDamageList.Count == 0)
{
halfDamageReady = false;
}
else
{
halfDamageReady = true;
}
}
[Server]
private void UpdateSecondHalfOfDamage(float deltaTime)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::UpdateSecondHalfOfDamage(System.Single)' called on client");
}
else
{
if (!halfDamageReady)
{
return;
}
for (int i = 0; i < incomingDamageList.Count; i++)
{
DelayedDamageInfo delayedDamageInfo = incomingDamageList[i];
DamageInfo halfDamage = delayedDamageInfo.halfDamage;
halfDamage.position = GetBody().corePosition;
if (protectFromOneShot)
{
halfDamage.damageType = DamageType.NonLethal;
}
delayedDamageInfo.timeUntilDamage -= deltaTime;
if (delayedDamageInfo.timeUntilDamage <= 0f)
{
Util.PlaySound("Play_item_proc_delayedDamage_2ndHit", base.gameObject);
healthComponent.TakeDamage(halfDamage);
RemoveBuff(DLC2Content.Buffs.DelayedDamageDebuff);
incomingDamageList.RemoveAt(i);
protectFromOneShot = false;
}
}
}
}
[ClientRpc]
public void RpcTeleportCharacterToSafety()
{
if (!hasEffectiveAuthority)
{
return;
}
Transform transform = modelLocator?.modelTransform;
if (!(transform == null))
{
CharacterModel component = transform.GetComponent<CharacterModel>();
Vector3 position = coreTransform.position;
int itemCount = inventory.GetItemCount(DLC2Content.Items.TeleportOnLowHealth);
BlastAttack blastAttack = new BlastAttack();
blastAttack.attacker = base.gameObject;
blastAttack.baseDamage = damage * ((float)itemCount * 3.5f);
blastAttack.baseForce = 2000f;
blastAttack.bonusForce = Vector3.zero;
blastAttack.attackerFiltering = AttackerFiltering.NeverHitSelf;
blastAttack.crit = RollCrit();
blastAttack.damageColorIndex = DamageColorIndex.Item;
blastAttack.damageType = DamageType.Generic;
blastAttack.falloffModel = BlastAttack.FalloffModel.None;
blastAttack.inflictor = base.gameObject;
blastAttack.position = position;
blastAttack.procChainMask = default(ProcChainMask);
blastAttack.procCoefficient = 1f;
blastAttack.radius = 25f;
blastAttack.losType = BlastAttack.LoSType.None;
blastAttack.teamIndex = TeamIndex.Player;
blastAttack.Fire();
EffectManager.SpawnEffect(CommonAssets.teleportOnLowHealthExplosion, new EffectData
{
origin = position,
scale = 50f,
rotation = Quaternion.identity
}, transmit: true);
Util.PlaySound("Play_item_proc_teleportOnLowHealth", base.gameObject);
NodeGraph nodeGraph = SceneInfo.instance.GetNodeGraph(MapNodeGroup.GraphType.Ground);
List<NodeGraph.NodeIndex> source = nodeGraph.FindNodesInRange(corePosition, 100f, 200f, HullMask.Human);
nodeGraph.GetNodePosition(source.First(), out var position2);
TeleportHelper.TeleportBody(this, position2);
TeleportOutController.AddTPOutEffect(component, 1f, 0f, 1f);
EffectManager.SpawnEffect(CommonAssets.teleportOnLowHealthVFX, new EffectData
{
origin = this.transform.position,
rotation = Quaternion.identity
}, transmit: true);
Vector3 normalized = (position - position2).normalized;
if ((bool)characterDirection)
{
characterDirection.forward = normalized;
}
if ((bool)master && (bool)master.playerCharacterMasterController)
{
master.playerCharacterMasterController.RedirectCamera(Quaternion.LookRotation(normalized).eulerAngles);
}
}
}
private void prayerBeadCalculateAppliedStats(float levelStat)
{
if (teamComponent.teamIndex == TeamIndex.Player)
{
float num = (float)GetBuffCount(DLC2Content.Buffs.ExtraStatsOnLevelUpBuff) * levelStat * (0.2f + 0.05f * (float)(inventory.GetItemCount(DLC2Content.Items.ExtraStatsOnLevelUp) - 1));
if (levelStat == levelMaxHealth)
{
_ = inventory.beadAppliedHealth;
inventory.beadAppliedHealth += num;
}
else if (levelStat == levelMaxShield)
{
_ = inventory.beadAppliedShield;
inventory.beadAppliedShield += num;
}
else if (levelStat == levelRegen)
{
_ = inventory.beadAppliedRegen;
inventory.beadAppliedRegen += num;
}
else if (levelStat == levelDamage)
{
_ = inventory.beadAppliedDamage;
inventory.beadAppliedDamage += num;
}
}
}
[HideInInspector]
public void runicLensUpdateVariables(float damage, Vector3 position, DamageInfo damageInfo, float blastForce, float blastRadius)
{
runicLensPosition = position;
runicLensImpactTime = Run.instance.time + 2f;
runicLensMeteorReady = true;
runicLensDamage = damage;
runicLensDamageInfo = damageInfo;
runicLensBlastForce = blastForce;
runicLensBlastRadius = blastRadius;
}
public void detonateRunicLensMeteor()
{
GameObject gameObject = LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/ImpactEffects/RunicMeteorStrikeImpact");
Util.PlaySound("Play_item_proc_meteorAttackOnHighDamage_impact", base.gameObject);
EffectData effectData = new EffectData
{
origin = runicLensPosition
};
EffectManager.SpawnEffect(gameObject, effectData, transmit: true);
BlastAttack blastAttack = new BlastAttack();
blastAttack.falloffModel = BlastAttack.FalloffModel.None;
blastAttack.inflictor = gameObject;
blastAttack.baseDamage = runicLensDamage;
blastAttack.baseForce = runicLensBlastForce;
blastAttack.attackerFiltering = AttackerFiltering.Default;
blastAttack.crit = runicLensDamageInfo.crit;
blastAttack.attacker = runicLensDamageInfo.attacker;
blastAttack.bonusForce = Vector3.zero;
blastAttack.damageColorIndex = DamageColorIndex.Item;
blastAttack.position = runicLensPosition;
blastAttack.procChainMask = default(ProcChainMask);
blastAttack.procCoefficient = 0.5f;
blastAttack.teamIndex = TeamIndex.Player;
blastAttack.radius = runicLensBlastRadius;
blastAttack.Fire();
}
public void TriggerEnemyDebuffs(DamageInfo damageInfo)
{
SphereSearch sphereSearch = new SphereSearch();
List<HurtBox> list = CollectionPool<HurtBox, List<HurtBox>>.RentCollection();
sphereSearch.mask = LayerIndex.entityPrecise.mask;
sphereSearch.origin = base.gameObject.transform.position;
sphereSearch.radius = 30f;
sphereSearch.queryTriggerInteraction = QueryTriggerInteraction.UseGlobal;
sphereSearch.RefreshCandidates();
sphereSearch.FilterCandidatesByHurtBoxTeam(TeamMask.GetEnemyTeams(teamComponent.teamIndex));
sphereSearch.OrderCandidatesByDistance();
sphereSearch.FilterCandidatesByDistinctHurtBoxEntities();
sphereSearch.GetHurtBoxes(list);
sphereSearch.ClearCandidates();
EffectManager.SpawnEffect(CommonAssets.thornExplosionEffect, new EffectData
{
origin = coreTransform.position,
scale = 60f,
rotation = Quaternion.identity
}, transmit: true);
Util.PlaySound("Play_item_proc_triggerEnemyDebuffs", base.gameObject);
for (int i = 0; i < list.Count; i++)
{
HurtBox hurtBox = list[i];
if (!hurtBox || !hurtBox.healthComponent || !hurtBox.healthComponent.alive)
{
continue;
}
CharacterBody body = hurtBox.healthComponent.body;
int itemCount = inventory.GetItemCount(DLC2Content.Items.TriggerEnemyDebuffs);
int num = 1;
if (!body.hasStackableDebuff)
{
DotController.InflictDot(body.gameObject, damageInfo.attacker, DotController.DotIndex.Bleed, 3f * damageInfo.procCoefficient);
continue;
}
int buffCount = body.GetBuffCount(RoR2Content.Buffs.OnFire);
if (buffCount > 0)
{
float num2 = 0.5f;
int num3 = num * itemCount;
InflictDotInfo inflictDotInfo = default(InflictDotInfo);
inflictDotInfo.attackerObject = damageInfo.attacker;
inflictDotInfo.victimObject = body.gameObject;
inflictDotInfo.totalDamage = damageInfo.damage * num2;
inflictDotInfo.damageMultiplier = 1f;
inflictDotInfo.dotIndex = DotController.DotIndex.Burn;
InflictDotInfo inflictDotInfo2 = inflictDotInfo;
for (int j = 0; j < num3; j++)
{
DotController.InflictDot(ref inflictDotInfo2);
}
}
buffCount = body.GetBuffCount(RoR2Content.Buffs.BeetleJuice);
if (buffCount > 0)
{
int newCount = buffCount + num * itemCount;
body.SetBuffCount(RoR2Content.Buffs.BeetleJuice.buffIndex, newCount);
}
buffCount = body.GetBuffCount(RoR2Content.Buffs.NullifyStack);
if (buffCount > 0)
{
int newCount2 = buffCount + num * itemCount;
body.SetBuffCount(RoR2Content.Buffs.NullifyStack.buffIndex, newCount2);
}
buffCount = body.GetBuffCount(RoR2Content.Buffs.Bleeding);
if (buffCount > 0)
{
int num4 = num * itemCount;
for (int k = 0; k < num4; k++)
{
DotController.InflictDot(body.gameObject, damageInfo.attacker, DotController.DotIndex.Bleed, 3f * damageInfo.procCoefficient);
}
}
buffCount = body.GetBuffCount(RoR2Content.Buffs.SuperBleed);
if (buffCount > 0)
{
int num5 = num * itemCount;
for (int l = 0; l < num5; l++)
{
DotController.InflictDot(body.gameObject, damageInfo.attacker, DotController.DotIndex.SuperBleed, 15f * damageInfo.procCoefficient);
}
}
buffCount = body.GetBuffCount(RoR2Content.Buffs.Blight);
if (buffCount > 0)
{
int num6 = num * itemCount;
for (int m = 0; m < num6; m++)
{
DotController.InflictDot(body.gameObject, damageInfo.attacker, DotController.DotIndex.Blight, 5f * damageInfo.procCoefficient);
}
}
buffCount = body.GetBuffCount(RoR2Content.Buffs.Overheat);
if (buffCount > 0)
{
int newCount3 = buffCount + num * itemCount;
body.SetBuffCount(RoR2Content.Buffs.Overheat.buffIndex, newCount3);
}
buffCount = body.GetBuffCount(RoR2Content.Buffs.PulverizeBuildup);
if (buffCount > 0)
{
int newCount4 = buffCount + num * itemCount;
body.SetBuffCount(RoR2Content.Buffs.PulverizeBuildup.buffIndex, newCount4);
}
buffCount = body.GetBuffCount(DLC1Content.Buffs.StrongerBurn);
if (buffCount > 0)
{
int num7 = num * itemCount;
for (int n = 0; n < num7; n++)
{
DotController.InflictDot(body.gameObject, damageInfo.attacker, DotController.DotIndex.StrongerBurn, 3f * damageInfo.procCoefficient);
}
}
buffCount = body.GetBuffCount(DLC1Content.Buffs.Fracture);
if (buffCount > 0)
{
int num8 = num * itemCount;
DotController.DotDef dotDef = DotController.GetDotDef(DotController.DotIndex.Fracture);
for (int num9 = 0; num9 < num8; num9++)
{
DotController.InflictDot(body.gameObject, damageInfo.attacker, DotController.DotIndex.Fracture, dotDef.interval);
}
}
buffCount = body.GetBuffCount(DLC1Content.Buffs.PermanentDebuff);
if (buffCount > 0)
{
int newCount5 = buffCount + num * itemCount;
body.SetBuffCount(DLC1Content.Buffs.PermanentDebuff.buffIndex, newCount5);
}
buffCount = body.GetBuffCount(DLC2Content.Buffs.lunarruin);
if (buffCount > 0)
{
int num10 = buffCount + num * itemCount;
body.SetBuffCount(DLC2Content.Buffs.lunarruin.buffIndex, num10);
for (int num11 = 0; num11 < num10; num11++)
{
DotController.InflictDot(body.gameObject, damageInfo.attacker, DotController.DotIndex.LunarRuin, 5f);
}
}
}
}
private void IncreaseStunPierceDamage(int kills)
{
}
public void ApplyTamperedHeartPassive(float heartRegen, float heartMSpeed, float heartDamage, float armor, float attackSpeed)
{
tamperedHeartActive = true;
tamperedHeartRegenBonus = heartRegen;
tamperedHeartMSpeedBonus = heartMSpeed;
tamperedHeartDamageBonus = heartDamage;
tamperedHeartAttackSpeedBonus = attackSpeed;
tamperedHeartArmorBonus = armor;
}
public void AddFreeChestBuff()
{
int itemCount = inventory.GetItemCount(DLC2Content.Items.OnLevelUpFreeUnlock);
for (int i = 0; i < itemCount; i++)
{
AddBuff(DLC2Content.Buffs.FreeUnlocks.buffIndex);
}
}
[ClientRpc]
public void RpcBark()
{
if ((bool)sfxLocator)
{
Util.PlaySound(sfxLocator.barkSound, base.gameObject);
}
}
[Command]
public void CmdRequestVehicleEjection()
{
if ((bool)currentVehicle)
{
currentVehicle.EjectPassenger(base.gameObject);
}
}
public bool RollCrit()
{
if ((bool)master)
{
return Util.CheckRoll(crit, master);
}
return false;
}
public bool IsCullable()
{
if (!dontCull && Importance - TeamComponent.GetTeamAverageImportance(teamComponent) < 3 && teamComponent.teamIndex != TeamIndex.Player && !isBoss)
{
return TeamComponent.GetTeamMembers(TeamIndex.Monster).Count >= 10;
}
return false;
}
public bool IsActivelyCullable()
{
if (!isBoss)
{
if (!NearAnyPlayers(75f))
{
return !CharacterIsVisible;
}
return false;
}
return false;
}
public bool NearAnyPlayers(float checkRadius)
{
float num = checkRadius * checkRadius;
foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
{
if ((bool)instance.master && (bool)instance.master.GetBody() && (transform.position - instance.master.GetBody().transform.position).sqrMagnitude < num)
{
return true;
}
}
return false;
}
[ClientRpc]
private void RpcUsePreferredInitialStateType()
{
if (hasEffectiveAuthority)
{
SetBodyStateToPreferredInitialState();
}
}
public void SetBodyStateToPreferredInitialState()
{
if (!hasEffectiveAuthority)
{
if (NetworkServer.active)
{
CallRpcUsePreferredInitialStateType();
}
return;
}
Type stateType = preferredInitialStateType.stateType;
if (!(stateType == null) && !(stateType == typeof(Uninitialized)))
{
EntityStateMachine.FindByCustomName(base.gameObject, "Body")?.SetState(EntityStateCatalog.InstantiateState(stateType));
}
}
[Server]
public void SetLoadoutServer(Loadout loadout)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.CharacterBody::SetLoadoutServer(RoR2.Loadout)' called on client");
}
else
{
skillLocator.ApplyLoadoutServer(loadout, bodyIndex);
}
}
static CharacterBody()
{
instancesList = new List<CharacterBody>();
readOnlyInstancesList = new ReadOnlyCollection<CharacterBody>(instancesList);
kCmdCmdAddTimedBuff = -160178508;
NetworkBehaviour.RegisterCommandDelegate(typeof(CharacterBody), kCmdCmdAddTimedBuff, InvokeCmdCmdAddTimedBuff);
kCmdCmdSetInLava = 234733148;
NetworkBehaviour.RegisterCommandDelegate(typeof(CharacterBody), kCmdCmdSetInLava, InvokeCmdCmdSetInLava);
kCmdCmdUpdateSprint = -1006016914;
NetworkBehaviour.RegisterCommandDelegate(typeof(CharacterBody), kCmdCmdUpdateSprint, InvokeCmdCmdUpdateSprint);
kCmdCmdOnSkillActivated = 384138986;
NetworkBehaviour.RegisterCommandDelegate(typeof(CharacterBody), kCmdCmdOnSkillActivated, InvokeCmdCmdOnSkillActivated);
kCmdCmdTransmitItemBehavior = 394448000;
NetworkBehaviour.RegisterCommandDelegate(typeof(CharacterBody), kCmdCmdTransmitItemBehavior, InvokeCmdCmdTransmitItemBehavior);
kCmdCmdSpawnDelayedDamageEffect = 1860577938;
NetworkBehaviour.RegisterCommandDelegate(typeof(CharacterBody), kCmdCmdSpawnDelayedDamageEffect, InvokeCmdCmdSpawnDelayedDamageEffect);
kCmdCmdRequestVehicleEjection = 1803737791;
NetworkBehaviour.RegisterCommandDelegate(typeof(CharacterBody), kCmdCmdRequestVehicleEjection, InvokeCmdCmdRequestVehicleEjection);
kRpcRpcTransmitItemBehavior = -729896618;
NetworkBehaviour.RegisterRpcDelegate(typeof(CharacterBody), kRpcRpcTransmitItemBehavior, InvokeRpcRpcTransmitItemBehavior);
kRpcRpcTeleportCharacterToSafety = -245876694;
NetworkBehaviour.RegisterRpcDelegate(typeof(CharacterBody), kRpcRpcTeleportCharacterToSafety, InvokeRpcRpcTeleportCharacterToSafety);
kRpcRpcBark = -76716871;
NetworkBehaviour.RegisterRpcDelegate(typeof(CharacterBody), kRpcRpcBark, InvokeRpcRpcBark);
kRpcRpcUsePreferredInitialStateType = 638695010;
NetworkBehaviour.RegisterRpcDelegate(typeof(CharacterBody), kRpcRpcUsePreferredInitialStateType, InvokeRpcRpcUsePreferredInitialStateType);
NetworkCRC.RegisterBehaviour("CharacterBody", 0);
}
private void UNetVersion()
{
}
protected static void InvokeCmdCmdAddTimedBuff(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkServer.active)
{
Debug.LogError("Command CmdAddTimedBuff called on client.");
}
else
{
((CharacterBody)obj).CmdAddTimedBuff((BuffIndex)reader.ReadInt32(), reader.ReadSingle());
}
}
protected static void InvokeCmdCmdSetInLava(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkServer.active)
{
Debug.LogError("Command CmdSetInLava called on client.");
}
else
{
((CharacterBody)obj).CmdSetInLava(reader.ReadBoolean());
}
}
protected static void InvokeCmdCmdUpdateSprint(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkServer.active)
{
Debug.LogError("Command CmdUpdateSprint called on client.");
}
else
{
((CharacterBody)obj).CmdUpdateSprint(reader.ReadBoolean());
}
}
protected static void InvokeCmdCmdOnSkillActivated(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkServer.active)
{
Debug.LogError("Command CmdOnSkillActivated called on client.");
}
else
{
((CharacterBody)obj).CmdOnSkillActivated((sbyte)reader.ReadPackedUInt32());
}
}
protected static void InvokeCmdCmdTransmitItemBehavior(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkServer.active)
{
Debug.LogError("Command CmdTransmitItemBehavior called on client.");
}
else
{
((CharacterBody)obj).CmdTransmitItemBehavior(GeneratedNetworkCode._ReadNetworkItemBehaviorData_CharacterBody(reader));
}
}
protected static void InvokeCmdCmdSpawnDelayedDamageEffect(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkServer.active)
{
Debug.LogError("Command CmdSpawnDelayedDamageEffect called on client.");
}
else
{
((CharacterBody)obj).CmdSpawnDelayedDamageEffect();
}
}
protected static void InvokeCmdCmdRequestVehicleEjection(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkServer.active)
{
Debug.LogError("Command CmdRequestVehicleEjection called on client.");
}
else
{
((CharacterBody)obj).CmdRequestVehicleEjection();
}
}
public void CallCmdAddTimedBuff(BuffIndex buffType, float duration)
{
if (!NetworkClient.active)
{
Debug.LogError("Command function CmdAddTimedBuff called on server.");
return;
}
if (base.isServer)
{
CmdAddTimedBuff(buffType, duration);
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)5);
networkWriter.WritePackedUInt32((uint)kCmdCmdAddTimedBuff);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
networkWriter.Write((int)buffType);
networkWriter.Write(duration);
SendCommandInternal(networkWriter, 0, "CmdAddTimedBuff");
}
public void CallCmdSetInLava(bool b)
{
if (!NetworkClient.active)
{
Debug.LogError("Command function CmdSetInLava called on server.");
return;
}
if (base.isServer)
{
CmdSetInLava(b);
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)5);
networkWriter.WritePackedUInt32((uint)kCmdCmdSetInLava);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
networkWriter.Write(b);
SendCommandInternal(networkWriter, 0, "CmdSetInLava");
}
public void CallCmdUpdateSprint(bool newIsSprinting)
{
if (!NetworkClient.active)
{
Debug.LogError("Command function CmdUpdateSprint called on server.");
return;
}
if (base.isServer)
{
CmdUpdateSprint(newIsSprinting);
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)5);
networkWriter.WritePackedUInt32((uint)kCmdCmdUpdateSprint);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
networkWriter.Write(newIsSprinting);
SendCommandInternal(networkWriter, 0, "CmdUpdateSprint");
}
public void CallCmdOnSkillActivated(sbyte skillIndex)
{
if (!NetworkClient.active)
{
Debug.LogError("Command function CmdOnSkillActivated called on server.");
return;
}
if (base.isServer)
{
CmdOnSkillActivated(skillIndex);
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)5);
networkWriter.WritePackedUInt32((uint)kCmdCmdOnSkillActivated);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
networkWriter.WritePackedUInt32((uint)skillIndex);
SendCommandInternal(networkWriter, 0, "CmdOnSkillActivated");
}
public void CallCmdTransmitItemBehavior(NetworkItemBehaviorData itemBehaviorData)
{
if (!NetworkClient.active)
{
Debug.LogError("Command function CmdTransmitItemBehavior called on server.");
return;
}
if (base.isServer)
{
CmdTransmitItemBehavior(itemBehaviorData);
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)5);
networkWriter.WritePackedUInt32((uint)kCmdCmdTransmitItemBehavior);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
GeneratedNetworkCode._WriteNetworkItemBehaviorData_CharacterBody(networkWriter, itemBehaviorData);
SendCommandInternal(networkWriter, 0, "CmdTransmitItemBehavior");
}
public void CallCmdSpawnDelayedDamageEffect()
{
if (!NetworkClient.active)
{
Debug.LogError("Command function CmdSpawnDelayedDamageEffect called on server.");
return;
}
if (base.isServer)
{
CmdSpawnDelayedDamageEffect();
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)5);
networkWriter.WritePackedUInt32((uint)kCmdCmdSpawnDelayedDamageEffect);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendCommandInternal(networkWriter, 0, "CmdSpawnDelayedDamageEffect");
}
public void CallCmdRequestVehicleEjection()
{
if (!NetworkClient.active)
{
Debug.LogError("Command function CmdRequestVehicleEjection called on server.");
return;
}
if (base.isServer)
{
CmdRequestVehicleEjection();
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)5);
networkWriter.WritePackedUInt32((uint)kCmdCmdRequestVehicleEjection);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendCommandInternal(networkWriter, 0, "CmdRequestVehicleEjection");
}
protected static void InvokeRpcRpcTransmitItemBehavior(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcTransmitItemBehavior called on server.");
}
else
{
((CharacterBody)obj).RpcTransmitItemBehavior(GeneratedNetworkCode._ReadNetworkItemBehaviorData_CharacterBody(reader));
}
}
protected static void InvokeRpcRpcTeleportCharacterToSafety(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcTeleportCharacterToSafety called on server.");
}
else
{
((CharacterBody)obj).RpcTeleportCharacterToSafety();
}
}
protected static void InvokeRpcRpcBark(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcBark called on server.");
}
else
{
((CharacterBody)obj).RpcBark();
}
}
protected static void InvokeRpcRpcUsePreferredInitialStateType(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcUsePreferredInitialStateType called on server.");
}
else
{
((CharacterBody)obj).RpcUsePreferredInitialStateType();
}
}
public void CallRpcTransmitItemBehavior(NetworkItemBehaviorData itemBehaviorData)
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcTransmitItemBehavior called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcTransmitItemBehavior);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
GeneratedNetworkCode._WriteNetworkItemBehaviorData_CharacterBody(networkWriter, itemBehaviorData);
SendRPCInternal(networkWriter, 1, "RpcTransmitItemBehavior");
}
public void CallRpcTeleportCharacterToSafety()
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcTeleportCharacterToSafety called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcTeleportCharacterToSafety);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendRPCInternal(networkWriter, 0, "RpcTeleportCharacterToSafety");
}
public void CallRpcBark()
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcBark called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcBark);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendRPCInternal(networkWriter, 0, "RpcBark");
}
public void CallRpcUsePreferredInitialStateType()
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcUsePreferredInitialStateType called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcUsePreferredInitialStateType);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendRPCInternal(networkWriter, 0, "RpcUsePreferredInitialStateType");
}
public override void PreStartClient()
{
}
}