5542 lines
156 KiB
C#
5542 lines
156 KiB
C#
|
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()
|
||
|
{
|
||
|
}
|
||
|
}
|