r2mods/ilspy_dump/ror2_csproj/RoR2/EquipmentSlot.cs

1597 lines
50 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using JetBrains.Annotations;
using RoR2.DirectionalSearch;
using RoR2.Orbs;
using RoR2.Projectile;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
namespace RoR2;
[RequireComponent(typeof(CharacterBody))]
public class EquipmentSlot : NetworkBehaviour
{
private struct UserTargetInfo
{
public readonly HurtBox hurtBox;
public readonly GameObject rootObject;
public readonly GenericPickupController pickupController;
public readonly Transform transformToIndicateAt;
public UserTargetInfo(HurtBox source)
{
hurtBox = source;
rootObject = (hurtBox ? hurtBox.healthComponent.gameObject : null);
pickupController = null;
transformToIndicateAt = (hurtBox ? hurtBox.transform : null);
}
public UserTargetInfo(GenericPickupController source)
{
pickupController = source;
hurtBox = null;
rootObject = (pickupController ? pickupController.gameObject : null);
transformToIndicateAt = (pickupController ? pickupController.pickupDisplay.transform : null);
}
}
private Inventory inventory;
private Run.FixedTimeStamp _rechargeTime;
private bool hasEffectiveAuthority;
private Xoroshiro128Plus rng;
private HealthComponent healthComponent;
private InputBankTest inputBank;
private TeamComponent teamComponent;
private const float fullCritDuration = 8f;
private static readonly float tonicBuffDuration;
public static string equipmentActivateString;
private float missileTimer;
private float bfgChargeTimer;
private float subcooldownTimer;
private const float missileInterval = 0.125f;
private int remainingMissiles;
private HealingFollowerController passiveHealingFollower;
private GameObject goldgatControllerObject;
private static int activeParamHash;
private static int activeDurationParamHash;
private static int activeStopwatchParamHash;
private Indicator targetIndicator;
private BullseyeSearch targetFinder = new BullseyeSearch();
private UserTargetInfo currentTarget;
private PickupSearch pickupSearch;
private Transform sproutSpawnTransform;
private GameObject playerRespawnEffectPrefab;
private bool sproutIsSpawned;
private GameObject sprout;
private static int kRpcRpcOnClientEquipmentActivationRecieved;
private static int kCmdCmdExecuteIfReady;
private static int kCmdCmdOnEquipmentExecuted;
public byte activeEquipmentSlot { get; private set; }
public EquipmentIndex equipmentIndex { get; private set; }
public int stock { get; private set; }
public int maxStock { get; private set; }
private bool equipmentDisabled
{
get
{
if (!inventory)
{
return false;
}
return inventory.GetEquipmentDisabled();
}
}
public CharacterBody characterBody { get; private set; }
public float cooldownTimer => _rechargeTime.timeUntil;
public static event Action<EquipmentSlot, EquipmentIndex> onServerEquipmentActivated;
public override void OnStartServer()
{
base.OnStartServer();
UpdateAuthority();
}
public override void OnStartAuthority()
{
base.OnStartAuthority();
UpdateAuthority();
}
public override void OnStopAuthority()
{
base.OnStopAuthority();
UpdateAuthority();
}
private void UpdateAuthority()
{
hasEffectiveAuthority = Util.HasEffectiveAuthority(base.gameObject);
}
private void UpdateInventory()
{
inventory = characterBody.inventory;
if ((bool)inventory)
{
activeEquipmentSlot = inventory.activeEquipmentSlot;
equipmentIndex = inventory.GetEquipmentIndex();
stock = inventory.GetEquipment(inventory.activeEquipmentSlot).charges;
maxStock = inventory.GetActiveEquipmentMaxCharges();
_rechargeTime = inventory.GetEquipment(inventory.activeEquipmentSlot).chargeFinishTime;
}
else
{
activeEquipmentSlot = 0;
equipmentIndex = EquipmentIndex.None;
stock = 0;
maxStock = 0;
_rechargeTime = Run.FixedTimeStamp.positiveInfinity;
}
}
[Server]
private void UpdateGoldGat()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.EquipmentSlot::UpdateGoldGat()' called on client");
return;
}
bool flag = equipmentIndex == RoR2Content.Equipment.GoldGat.equipmentIndex;
if (flag != (bool)goldgatControllerObject)
{
if (flag)
{
goldgatControllerObject = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/GoldGatController"));
goldgatControllerObject.GetComponent<NetworkedBodyAttachment>().AttachToGameObjectAndSpawn(base.gameObject);
}
else
{
UnityEngine.Object.Destroy(goldgatControllerObject);
}
}
}
public Transform FindActiveEquipmentDisplay()
{
ModelLocator component = GetComponent<ModelLocator>();
if ((bool)component)
{
Transform modelTransform = component.modelTransform;
if ((bool)modelTransform)
{
CharacterModel component2 = modelTransform.GetComponent<CharacterModel>();
if ((bool)component2)
{
List<GameObject> equipmentDisplayObjects = component2.GetEquipmentDisplayObjects(equipmentIndex);
if (equipmentDisplayObjects.Count > 0)
{
return equipmentDisplayObjects[0].transform;
}
}
}
}
return null;
}
[ClientRpc]
private void RpcOnClientEquipmentActivationRecieved()
{
Util.PlaySound(equipmentActivateString, base.gameObject);
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
if (equipmentDef == RoR2Content.Equipment.DroneBackup)
{
Util.PlaySound("Play_item_use_radio", base.gameObject);
}
else if (equipmentDef == RoR2Content.Equipment.BFG)
{
Transform transform = FindActiveEquipmentDisplay();
if ((bool)transform)
{
Animator componentInChildren = transform.GetComponentInChildren<Animator>();
if ((bool)componentInChildren)
{
componentInChildren.SetTrigger("Fire");
}
}
}
else if (equipmentDef == RoR2Content.Equipment.Blackhole)
{
Transform transform2 = FindActiveEquipmentDisplay();
if ((bool)transform2)
{
GravCubeController component = transform2.GetComponent<GravCubeController>();
if ((bool)component)
{
component.ActivateCube(9f);
}
}
}
else if (equipmentDef == RoR2Content.Equipment.CritOnUse)
{
Transform transform3 = FindActiveEquipmentDisplay();
if ((bool)transform3)
{
Animator componentInChildren2 = transform3.GetComponentInChildren<Animator>();
if ((bool)componentInChildren2)
{
componentInChildren2.SetBool(activeParamHash, value: true);
componentInChildren2.SetFloat(activeDurationParamHash, 8f);
componentInChildren2.SetFloat(activeStopwatchParamHash, 0f);
}
}
}
else if (equipmentDef == RoR2Content.Equipment.GainArmor)
{
Util.PlaySound("Play_item_use_gainArmor", base.gameObject);
}
}
private void Start()
{
characterBody = GetComponent<CharacterBody>();
healthComponent = GetComponent<HealthComponent>();
inputBank = GetComponent<InputBankTest>();
teamComponent = GetComponent<TeamComponent>();
targetIndicator = new Indicator(base.gameObject, null);
rng = new Xoroshiro128Plus(Run.instance.seed ^ (ulong)Run.instance.stageClearCount);
}
private void OnDestroy()
{
if (targetIndicator != null)
{
targetIndicator.active = false;
}
}
private void FixedUpdate()
{
MyFixedUpdate(Time.fixedDeltaTime);
}
private void MyFixedUpdate(float deltaTime)
{
UpdateInventory();
if (NetworkServer.active && !equipmentDisabled)
{
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
subcooldownTimer -= deltaTime;
if (missileTimer > 0f)
{
missileTimer = Mathf.Max(missileTimer - deltaTime, 0f);
}
if (missileTimer == 0f && remainingMissiles > 0)
{
remainingMissiles--;
missileTimer = 0.125f;
FireMissile();
}
UpdateGoldGat();
if (bfgChargeTimer > 0f)
{
bfgChargeTimer -= deltaTime;
if (bfgChargeTimer < 0f)
{
_ = base.transform.position;
Ray aimRay = GetAimRay();
Transform transform = FindActiveEquipmentDisplay();
if ((bool)transform)
{
ChildLocator componentInChildren = transform.GetComponentInChildren<ChildLocator>();
if ((bool)componentInChildren)
{
Transform transform2 = componentInChildren.FindChild("Muzzle");
if ((bool)transform2)
{
aimRay.origin = transform2.position;
}
}
}
healthComponent.TakeDamageForce(aimRay.direction * -1500f, alwaysApply: true);
ProjectileManager.instance.FireProjectile(LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/BeamSphere"), aimRay.origin, Util.QuaternionSafeLookRotation(aimRay.direction), base.gameObject, characterBody.damage * 2f, 0f, Util.CheckRoll(characterBody.crit, characterBody.master), DamageColorIndex.Item);
bfgChargeTimer = 0f;
}
}
if (equipmentDef == RoR2Content.Equipment.PassiveHealing != (bool)passiveHealingFollower)
{
if (!passiveHealingFollower)
{
GameObject gameObject = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/HealingFollower"), base.transform.position, Quaternion.identity);
passiveHealingFollower = gameObject.GetComponent<HealingFollowerController>();
passiveHealingFollower.NetworkownerBodyObject = base.gameObject;
NetworkServer.Spawn(gameObject);
}
else
{
UnityEngine.Object.Destroy(passiveHealingFollower.gameObject);
passiveHealingFollower = null;
}
}
}
bool num = inputBank.activateEquipment.justPressed || (inventory?.GetItemCount(RoR2Content.Items.AutoCastEquipment) ?? 0) > 0;
bool isEquipmentActivationAllowed = characterBody.isEquipmentActivationAllowed;
if (num && isEquipmentActivationAllowed && hasEffectiveAuthority)
{
if (NetworkServer.active)
{
ExecuteIfReady();
}
else
{
CallCmdExecuteIfReady();
}
}
}
[Command]
private void CmdExecuteIfReady()
{
ExecuteIfReady();
}
[Server]
public bool ExecuteIfReady()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Boolean RoR2.EquipmentSlot::ExecuteIfReady()' called on client");
return false;
}
if (equipmentIndex != EquipmentIndex.None && stock > 0)
{
Execute();
return true;
}
return false;
}
[Server]
private void Execute()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.EquipmentSlot::Execute()' called on client");
return;
}
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
if ((object)equipmentDef != null && subcooldownTimer <= 0f && PerformEquipmentAction(equipmentDef))
{
OnEquipmentExecuted();
}
}
[Command]
public void CmdOnEquipmentExecuted()
{
OnEquipmentExecuted();
}
[Server]
public void OnEquipmentExecuted()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.EquipmentSlot::OnEquipmentExecuted()' called on client");
return;
}
EquipmentIndex arg = this.equipmentIndex;
inventory.DeductEquipmentCharges(activeEquipmentSlot, 1);
UpdateInventory();
CallRpcOnClientEquipmentActivationRecieved();
EquipmentSlot.onServerEquipmentActivated?.Invoke(this, arg);
if (!characterBody || !inventory)
{
return;
}
int itemCount = inventory.GetItemCount(RoR2Content.Items.EnergizedOnEquipmentUse);
if (itemCount > 0)
{
characterBody.AddTimedBuff(RoR2Content.Buffs.Energized, 8 + 4 * (itemCount - 1));
}
int itemCount2 = inventory.GetItemCount(DLC1Content.Items.RandomEquipmentTrigger);
if (itemCount2 <= 0 || EquipmentCatalog.randomTriggerEquipmentList.Count <= 0)
{
return;
}
List<EquipmentIndex> list = new List<EquipmentIndex>(EquipmentCatalog.randomTriggerEquipmentList);
if (inventory.currentEquipmentIndex != EquipmentIndex.None)
{
list.Remove(inventory.currentEquipmentIndex);
}
Util.ShuffleList(list, rng);
if (inventory.currentEquipmentIndex != EquipmentIndex.None)
{
list.Add(inventory.currentEquipmentIndex);
}
int num = 0;
bool flag = false;
bool flag2 = false;
for (int i = 0; i < itemCount2; i++)
{
if (flag2)
{
break;
}
EquipmentIndex equipmentIndex = EquipmentIndex.None;
do
{
if (num >= list.Count)
{
if (!flag)
{
flag2 = true;
break;
}
flag = false;
num %= list.Count;
}
equipmentIndex = list[num];
num++;
}
while (!PerformEquipmentAction(EquipmentCatalog.GetEquipmentDef(equipmentIndex)));
if (equipmentIndex == RoR2Content.Equipment.BFG.equipmentIndex)
{
ModelLocator component = GetComponent<ModelLocator>();
if ((bool)component)
{
Transform modelTransform = component.modelTransform;
if ((bool)modelTransform)
{
CharacterModel component2 = modelTransform.GetComponent<CharacterModel>();
if ((bool)component2)
{
List<GameObject> itemDisplayObjects = component2.GetItemDisplayObjects(DLC1Content.Items.RandomEquipmentTrigger.itemIndex);
if (itemDisplayObjects.Count > 0)
{
UnityEngine.Object.Instantiate(Addressables.LoadAssetAsync<GameObject>("RoR2/Base/BFG/ChargeBFG.prefab").WaitForCompletion(), itemDisplayObjects[0].transform);
}
}
}
}
}
flag = true;
}
EffectData effectData = new EffectData();
effectData.origin = characterBody.corePosition;
effectData.SetNetworkedObjectReference(base.gameObject);
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/RandomEquipmentTriggerProcEffect"), effectData, transmit: true);
}
private void FireMissile()
{
GameObject projectilePrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/MissileProjectile");
float num = 3f;
bool isCrit = Util.CheckRoll(characterBody.crit, characterBody.master);
MissileUtils.FireMissile(characterBody.corePosition, characterBody, default(ProcChainMask), null, characterBody.damage * num, isCrit, projectilePrefab, DamageColorIndex.Item, addMissileProc: false);
}
[Server]
private bool PerformEquipmentAction(EquipmentDef equipmentDef)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Boolean RoR2.EquipmentSlot::PerformEquipmentAction(RoR2.EquipmentDef)' called on client");
return false;
}
if (equipmentDisabled)
{
return false;
}
Func<bool> func = null;
if (equipmentDef == RoR2Content.Equipment.CommandMissile)
{
func = FireCommandMissile;
}
else if (equipmentDef == RoR2Content.Equipment.Fruit)
{
func = FireFruit;
}
else if (equipmentDef == RoR2Content.Equipment.DroneBackup)
{
func = FireDroneBackup;
}
else if (equipmentDef == RoR2Content.Equipment.Meteor)
{
func = FireMeteor;
}
else if (equipmentDef == RoR2Content.Equipment.Blackhole)
{
func = FireBlackhole;
}
else if (equipmentDef == RoR2Content.Equipment.Saw)
{
func = FireSaw;
}
else if (equipmentDef == JunkContent.Equipment.OrbitalLaser)
{
func = FireOrbitalLaser;
}
else if (equipmentDef == JunkContent.Equipment.GhostGun)
{
func = FireGhostGun;
}
else if (equipmentDef == RoR2Content.Equipment.CritOnUse)
{
func = FireCritOnUse;
}
else if (equipmentDef == RoR2Content.Equipment.BFG)
{
func = FireBfg;
}
else if (equipmentDef == RoR2Content.Equipment.Jetpack)
{
func = FireJetpack;
}
else if (equipmentDef == RoR2Content.Equipment.Lightning)
{
func = FireLightning;
}
else if (equipmentDef == RoR2Content.Equipment.PassiveHealing)
{
func = FirePassiveHealing;
}
else if (equipmentDef == RoR2Content.Equipment.BurnNearby)
{
func = FireBurnNearby;
}
else if (equipmentDef == JunkContent.Equipment.SoulCorruptor)
{
func = FireSoulCorruptor;
}
else if (equipmentDef == RoR2Content.Equipment.Scanner)
{
func = FireScanner;
}
else if (equipmentDef == RoR2Content.Equipment.CrippleWard)
{
func = FireCrippleWard;
}
else if (equipmentDef == RoR2Content.Equipment.Gateway)
{
func = FireGateway;
}
else if (equipmentDef == RoR2Content.Equipment.Tonic)
{
func = FireTonic;
}
else if (equipmentDef == RoR2Content.Equipment.Cleanse)
{
func = FireCleanse;
}
else if (equipmentDef == RoR2Content.Equipment.FireBallDash)
{
func = FireFireBallDash;
}
else if (equipmentDef == RoR2Content.Equipment.Recycle)
{
func = FireRecycle;
}
else if (equipmentDef == RoR2Content.Equipment.GainArmor)
{
func = FireGainArmor;
}
else if (equipmentDef == RoR2Content.Equipment.LifestealOnHit)
{
func = FireLifeStealOnHit;
}
else if (equipmentDef == RoR2Content.Equipment.TeamWarCry)
{
func = FireTeamWarCry;
}
else if (equipmentDef == RoR2Content.Equipment.DeathProjectile)
{
func = FireDeathProjectile;
}
else if (equipmentDef == DLC1Content.Equipment.Molotov)
{
func = FireMolotov;
}
else if (equipmentDef == DLC1Content.Equipment.VendingMachine)
{
func = FireVendingMachine;
}
else if (equipmentDef == DLC1Content.Equipment.BossHunter)
{
func = FireBossHunter;
}
else if (equipmentDef == DLC1Content.Equipment.BossHunterConsumed)
{
func = FireBossHunterConsumed;
}
else if (equipmentDef == DLC1Content.Equipment.GummyClone)
{
func = FireGummyClone;
}
else if (equipmentDef == DLC1Content.Equipment.LunarPortalOnUse)
{
func = FireLunarPortalOnUse;
}
else if (equipmentDef == DLC2Content.Equipment.HealAndRevive)
{
func = FireHealAndRevive;
}
else if (equipmentDef == DLC2Content.Equipment.HealAndReviveConsumed)
{
func = FireSproutOfLife;
}
return func?.Invoke() ?? false;
}
private Ray GetAimRay()
{
Ray result = default(Ray);
result.direction = inputBank.aimDirection;
result.origin = inputBank.aimOrigin;
return result;
}
[CanBeNull]
[Server]
private CharacterMaster SummonMaster([NotNull] GameObject masterPrefab, Vector3 position, Quaternion rotation)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'RoR2.CharacterMaster RoR2.EquipmentSlot::SummonMaster(UnityEngine.GameObject,UnityEngine.Vector3,UnityEngine.Quaternion)' called on client");
return null;
}
return new MasterSummon
{
masterPrefab = masterPrefab,
position = position,
rotation = rotation,
summonerBodyObject = base.gameObject,
ignoreTeamMemberLimit = false
}.Perform();
}
private void ConfigureTargetFinderBase()
{
targetFinder.teamMaskFilter = TeamMask.allButNeutral;
targetFinder.teamMaskFilter.RemoveTeam(teamComponent.teamIndex);
targetFinder.sortMode = BullseyeSearch.SortMode.Angle;
targetFinder.filterByLoS = true;
float extraRaycastDistance;
Ray ray = CameraRigController.ModifyAimRayIfApplicable(GetAimRay(), base.gameObject, out extraRaycastDistance);
targetFinder.searchOrigin = ray.origin;
targetFinder.searchDirection = ray.direction;
targetFinder.maxAngleFilter = 10f;
targetFinder.viewer = characterBody;
}
private void ConfigureTargetFinderForEnemies()
{
ConfigureTargetFinderBase();
targetFinder.teamMaskFilter = TeamMask.GetUnprotectedTeams(teamComponent.teamIndex);
targetFinder.RefreshCandidates();
targetFinder.FilterOutGameObject(base.gameObject);
}
private void ConfigureTargetFinderForBossesWithRewards()
{
ConfigureTargetFinderBase();
targetFinder.teamMaskFilter = TeamMask.GetUnprotectedTeams(teamComponent.teamIndex);
targetFinder.RefreshCandidates();
targetFinder.FilterOutGameObject(base.gameObject);
}
private void ConfigureTargetFinderForFriendlies()
{
ConfigureTargetFinderBase();
targetFinder.teamMaskFilter = TeamMask.none;
targetFinder.teamMaskFilter.AddTeam(teamComponent.teamIndex);
targetFinder.RefreshCandidates();
targetFinder.FilterOutGameObject(base.gameObject);
}
private void InvalidateCurrentTarget()
{
currentTarget = default(UserTargetInfo);
}
private void UpdateTargets(EquipmentIndex targetingEquipmentIndex, bool userShouldAnticipateTarget)
{
bool flag = targetingEquipmentIndex == DLC1Content.Equipment.BossHunter.equipmentIndex;
bool flag2 = (targetingEquipmentIndex == RoR2Content.Equipment.Lightning.equipmentIndex || targetingEquipmentIndex == JunkContent.Equipment.SoulCorruptor.equipmentIndex || flag) && userShouldAnticipateTarget;
bool flag3 = targetingEquipmentIndex == RoR2Content.Equipment.PassiveHealing.equipmentIndex && userShouldAnticipateTarget;
bool num = flag2 || flag3;
bool flag4 = targetingEquipmentIndex == RoR2Content.Equipment.Recycle.equipmentIndex;
if (num)
{
if (flag2)
{
ConfigureTargetFinderForEnemies();
}
if (flag3)
{
ConfigureTargetFinderForFriendlies();
}
HurtBox source = null;
if (flag)
{
foreach (HurtBox result in targetFinder.GetResults())
{
if ((bool)result && (bool)result.healthComponent && (bool)result.healthComponent.body)
{
DeathRewards component = result.healthComponent.body.gameObject.GetComponent<DeathRewards>();
if ((bool)component && (bool)component.bossDropTable && !result.healthComponent.body.HasBuff(RoR2Content.Buffs.Immune))
{
source = result;
break;
}
}
}
}
else
{
source = targetFinder.GetResults().FirstOrDefault();
}
currentTarget = new UserTargetInfo(source);
}
else if (flag4)
{
currentTarget = new UserTargetInfo(FindPickupController(GetAimRay(), 10f, 30f, requireLoS: true, targetingEquipmentIndex == RoR2Content.Equipment.Recycle.equipmentIndex));
}
else
{
currentTarget = default(UserTargetInfo);
}
GenericPickupController pickupController = currentTarget.pickupController;
bool flag5 = currentTarget.transformToIndicateAt;
if (flag5)
{
if (targetingEquipmentIndex == RoR2Content.Equipment.Lightning.equipmentIndex)
{
targetIndicator.visualizerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/LightningIndicator");
}
else if (targetingEquipmentIndex == RoR2Content.Equipment.PassiveHealing.equipmentIndex)
{
targetIndicator.visualizerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/WoodSpriteIndicator");
}
else if (targetingEquipmentIndex == RoR2Content.Equipment.Recycle.equipmentIndex)
{
if (!pickupController.Recycled)
{
targetIndicator.visualizerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/RecyclerIndicator");
}
else
{
targetIndicator.visualizerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/RecyclerBadIndicator");
}
}
else if (targetingEquipmentIndex == DLC1Content.Equipment.BossHunter.equipmentIndex)
{
targetIndicator.visualizerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/BossHunterIndicator");
}
else
{
targetIndicator.visualizerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/LightningIndicator");
}
}
targetIndicator.active = flag5;
targetIndicator.targetTransform = (flag5 ? currentTarget.transformToIndicateAt : null);
}
private GenericPickupController FindPickupController(Ray aimRay, float maxAngle, float maxDistance, bool requireLoS, bool requireTransmutable)
{
if (pickupSearch == null)
{
pickupSearch = new PickupSearch();
}
aimRay = CameraRigController.ModifyAimRayIfApplicable(aimRay, base.gameObject, out var extraRaycastDistance);
pickupSearch.searchOrigin = aimRay.origin;
pickupSearch.searchDirection = aimRay.direction;
pickupSearch.minAngleFilter = 0f;
pickupSearch.maxAngleFilter = maxAngle;
pickupSearch.minDistanceFilter = 0f;
pickupSearch.maxDistanceFilter = maxDistance + extraRaycastDistance;
pickupSearch.filterByDistinctEntity = false;
pickupSearch.filterByLoS = requireLoS;
pickupSearch.sortMode = SortMode.DistanceAndAngle;
pickupSearch.requireTransmutable = requireTransmutable;
return pickupSearch.SearchCandidatesForSingleTarget(InstanceTracker.GetInstancesList<GenericPickupController>());
}
private void Update()
{
if (!equipmentDisabled)
{
UpdateTargets(equipmentIndex, stock > 0);
}
}
private bool FireCommandMissile()
{
remainingMissiles += 12;
return true;
}
private bool FireFruit()
{
if ((bool)healthComponent)
{
EffectData effectData = new EffectData();
effectData.origin = base.transform.position;
effectData.SetNetworkedObjectReference(base.gameObject);
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/FruitHealEffect"), effectData, transmit: true);
healthComponent.HealFraction(0.5f, default(ProcChainMask));
}
return true;
}
private bool FireDroneBackup()
{
int sliceCount = 4;
float num = 25f;
if (NetworkServer.active)
{
float y = Quaternion.LookRotation(GetAimRay().direction).eulerAngles.y;
float num2 = 3f;
foreach (float item in new DegreeSlices(sliceCount, 0.5f))
{
Quaternion quaternion = Quaternion.Euler(-30f, y + item, 0f);
Quaternion rotation = Quaternion.Euler(0f, y + item + 180f, 0f);
Vector3 position = base.transform.position + quaternion * (Vector3.forward * num2);
CharacterMaster characterMaster = SummonMaster(LegacyResourcesAPI.Load<GameObject>("Prefabs/CharacterMasters/DroneBackupMaster"), position, rotation);
if ((bool)characterMaster)
{
characterMaster.gameObject.AddComponent<MasterSuicideOnTimer>().lifeTimer = num + UnityEngine.Random.Range(0f, 3f);
}
}
}
subcooldownTimer = 0.5f;
return true;
}
private bool FireMeteor()
{
MeteorStormController component = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/MeteorStorm"), characterBody.corePosition, Quaternion.identity).GetComponent<MeteorStormController>();
component.owner = base.gameObject;
component.ownerDamage = characterBody.damage;
component.isCrit = Util.CheckRoll(characterBody.crit, characterBody.master);
NetworkServer.Spawn(component.gameObject);
return true;
}
private bool FireBlackhole()
{
Vector3 position = base.transform.position;
Ray aimRay = GetAimRay();
ProjectileManager.instance.FireProjectile(LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/GravSphere"), position, Util.QuaternionSafeLookRotation(aimRay.direction), base.gameObject, 0f, 0f, crit: false);
return true;
}
private bool FireSaw()
{
Ray aimRay = GetAimRay();
Quaternion quaternion = Quaternion.LookRotation(aimRay.direction);
float num = 15f;
FireSingleSaw(characterBody, aimRay.origin, quaternion * Quaternion.Euler(0f, 0f - num, 0f));
FireSingleSaw(characterBody, aimRay.origin, quaternion);
FireSingleSaw(characterBody, aimRay.origin, quaternion * Quaternion.Euler(0f, num, 0f));
return true;
void FireSingleSaw(CharacterBody firingCharacterBody, Vector3 origin, Quaternion rotation)
{
GameObject projectilePrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/Sawmerang");
FireProjectileInfo fireProjectileInfo = default(FireProjectileInfo);
fireProjectileInfo.projectilePrefab = projectilePrefab;
fireProjectileInfo.crit = characterBody.RollCrit();
fireProjectileInfo.damage = characterBody.damage;
fireProjectileInfo.damageColorIndex = DamageColorIndex.Item;
fireProjectileInfo.force = 0f;
fireProjectileInfo.owner = base.gameObject;
fireProjectileInfo.position = origin;
fireProjectileInfo.rotation = rotation;
FireProjectileInfo fireProjectileInfo2 = fireProjectileInfo;
ProjectileManager.instance.FireProjectile(fireProjectileInfo2);
}
}
private bool FireOrbitalLaser()
{
Vector3 position = base.transform.position;
if (Physics.Raycast(GetAimRay(), out var hitInfo, 900f, (int)LayerIndex.world.mask | (int)LayerIndex.CommonMasks.characterBodiesOrDefault))
{
position = hitInfo.point;
}
GameObject obj = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/OrbitalLaser"), position, Quaternion.identity);
obj.GetComponent<OrbitalLaserController>().ownerBody = characterBody;
NetworkServer.Spawn(obj);
return true;
}
private bool FireGhostGun()
{
GameObject obj = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/GhostGun"), base.transform.position, Quaternion.identity);
obj.GetComponent<GhostGunController>().owner = base.gameObject;
NetworkServer.Spawn(obj);
return true;
}
private bool FireCritOnUse()
{
characterBody.AddTimedBuff(RoR2Content.Buffs.FullCrit, 8f);
return true;
}
private bool FireBfg()
{
bfgChargeTimer = 2f;
subcooldownTimer = 2.2f;
return true;
}
private bool FireJetpack()
{
JetpackController jetpackController = JetpackController.FindJetpackController(base.gameObject);
if (!jetpackController)
{
UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/BodyAttachments/JetpackController")).GetComponent<NetworkedBodyAttachment>().AttachToGameObjectAndSpawn(base.gameObject);
}
else
{
jetpackController.ResetTimer();
}
return true;
}
private bool FireLightning()
{
UpdateTargets(RoR2Content.Equipment.Lightning.equipmentIndex, userShouldAnticipateTarget: true);
HurtBox hurtBox = currentTarget.hurtBox;
if ((bool)hurtBox)
{
subcooldownTimer = 0.2f;
OrbManager.instance.AddOrb(new LightningStrikeOrb
{
attacker = base.gameObject,
damageColorIndex = DamageColorIndex.Item,
damageValue = characterBody.damage * 30f,
isCrit = Util.CheckRoll(characterBody.crit, characterBody.master),
procChainMask = default(ProcChainMask),
procCoefficient = 1f,
target = hurtBox
});
InvalidateCurrentTarget();
return true;
}
return false;
}
private bool FireBossHunter()
{
UpdateTargets(DLC1Content.Equipment.BossHunter.equipmentIndex, userShouldAnticipateTarget: true);
HurtBox hurtBox = currentTarget.hurtBox;
DeathRewards deathRewards = hurtBox?.healthComponent?.body?.gameObject?.GetComponent<DeathRewards>();
if ((bool)hurtBox && (bool)deathRewards)
{
Vector3 vector = (hurtBox.transform ? hurtBox.transform.position : Vector3.zero);
Vector3 normalized = (vector - characterBody.corePosition).normalized;
PickupDropletController.CreatePickupDroplet(deathRewards.bossDropTable.GenerateDrop(rng), vector, normalized * 15f);
if ((bool)hurtBox?.healthComponent?.body?.master)
{
hurtBox.healthComponent.body.master.TrueKill(base.gameObject);
}
CharacterModel component = hurtBox.hurtBoxGroup.GetComponent<CharacterModel>();
if ((bool)component)
{
TemporaryOverlayInstance temporaryOverlayInstance = TemporaryOverlayManager.AddOverlay(component.gameObject);
temporaryOverlayInstance.duration = 0.1f;
temporaryOverlayInstance.animateShaderAlpha = true;
temporaryOverlayInstance.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
temporaryOverlayInstance.destroyComponentOnEnd = true;
temporaryOverlayInstance.originalMaterial = LegacyResourcesAPI.Load<Material>("Materials/matHuntressFlashBright");
temporaryOverlayInstance.AddToCharacterModel(component);
TemporaryOverlayInstance temporaryOverlayInstance2 = TemporaryOverlayManager.AddOverlay(component.gameObject);
temporaryOverlayInstance2.duration = 1.2f;
temporaryOverlayInstance2.animateShaderAlpha = true;
temporaryOverlayInstance2.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
temporaryOverlayInstance2.destroyComponentOnEnd = true;
temporaryOverlayInstance2.originalMaterial = LegacyResourcesAPI.Load<Material>("Materials/matGhostEffect");
temporaryOverlayInstance2.AddToCharacterModel(component);
}
DamageInfo damageInfo = new DamageInfo();
damageInfo.attacker = base.gameObject;
damageInfo.force = -normalized * 2500f;
healthComponent.TakeDamageForce(damageInfo, alwaysApply: true);
GameObject effectPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/BossHunterKillEffect");
Quaternion rotation = Util.QuaternionSafeLookRotation(normalized, Vector3.up);
EffectManager.SpawnEffect(effectPrefab, new EffectData
{
origin = vector,
rotation = rotation
}, transmit: true);
CharacterModel characterModel = base.gameObject.GetComponent<ModelLocator>()?.modelTransform?.GetComponent<CharacterModel>();
if ((bool)characterModel)
{
foreach (GameObject equipmentDisplayObject in characterModel.GetEquipmentDisplayObjects(DLC1Content.Equipment.BossHunter.equipmentIndex))
{
if (equipmentDisplayObject.name.Contains("DisplayTricorn"))
{
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/BossHunterHatEffect"), new EffectData
{
origin = equipmentDisplayObject.transform.position,
rotation = equipmentDisplayObject.transform.rotation,
scale = equipmentDisplayObject.transform.localScale.x
}, transmit: true);
}
else
{
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/BossHunterGunEffect"), new EffectData
{
origin = equipmentDisplayObject.transform.position,
rotation = Util.QuaternionSafeLookRotation(vector - equipmentDisplayObject.transform.position, Vector3.up),
scale = equipmentDisplayObject.transform.localScale.x
}, transmit: true);
}
}
}
if ((bool)characterBody?.inventory)
{
CharacterMasterNotificationQueue.SendTransformNotification(characterBody.master, characterBody.inventory.currentEquipmentIndex, DLC1Content.Equipment.BossHunterConsumed.equipmentIndex, CharacterMasterNotificationQueue.TransformationType.Default);
characterBody.inventory.SetEquipmentIndex(DLC1Content.Equipment.BossHunterConsumed.equipmentIndex);
}
InvalidateCurrentTarget();
return true;
}
return false;
}
private bool FireBossHunterConsumed()
{
if ((bool)characterBody)
{
Chat.SendBroadcastChat(new Chat.BodyChatMessage
{
bodyObject = characterBody.gameObject,
token = "EQUIPMENT_BOSSHUNTERCONSUMED_CHAT"
});
subcooldownTimer = 1f;
}
return true;
}
private bool FirePassiveHealing()
{
UpdateTargets(RoR2Content.Equipment.PassiveHealing.equipmentIndex, userShouldAnticipateTarget: true);
CharacterBody characterBody = currentTarget.rootObject?.GetComponent<CharacterBody>() ?? this.characterBody;
if ((bool)characterBody)
{
EffectManager.SimpleImpactEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/WoodSpriteHeal"), characterBody.corePosition, Vector3.up, transmit: true);
characterBody.healthComponent?.HealFraction(0.1f, default(ProcChainMask));
}
if ((bool)passiveHealingFollower)
{
passiveHealingFollower.AssignNewTarget(currentTarget.rootObject);
InvalidateCurrentTarget();
}
return true;
}
private bool FireBurnNearby()
{
if ((bool)characterBody)
{
characterBody.AddHelfireDuration(12f);
}
return true;
}
private bool FireSoulCorruptor()
{
UpdateTargets(JunkContent.Equipment.SoulCorruptor.equipmentIndex, userShouldAnticipateTarget: true);
HurtBox hurtBox = currentTarget.hurtBox;
if (!hurtBox)
{
return false;
}
if (!hurtBox.healthComponent || hurtBox.healthComponent.combinedHealthFraction > 0.25f)
{
return false;
}
Util.TryToCreateGhost(hurtBox.healthComponent.body, characterBody, 30);
hurtBox.healthComponent.Suicide(base.gameObject);
InvalidateCurrentTarget();
return true;
}
private bool FireScanner()
{
NetworkServer.Spawn(UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/ChestScanner"), characterBody.corePosition, Quaternion.identity));
return true;
}
private bool FireCrippleWard()
{
characterBody.master.GetDeployableCount(DeployableSlot.PowerWard);
Ray aimRay = GetAimRay();
float maxDistance = 1000f;
if (Physics.Raycast(aimRay, out var hitInfo, maxDistance, LayerIndex.world.mask, QueryTriggerInteraction.Ignore))
{
GameObject obj = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/CrippleWard"), hitInfo.point, Util.QuaternionSafeLookRotation(hitInfo.normal, Vector3.forward));
Deployable component = obj.GetComponent<Deployable>();
characterBody.master.AddDeployable(component, DeployableSlot.CrippleWard);
NetworkServer.Spawn(obj);
return true;
}
return true;
}
private bool FireTonic()
{
characterBody.AddTimedBuff(RoR2Content.Buffs.TonicBuff, tonicBuffDuration);
if (!Util.CheckRoll(80f, characterBody.master))
{
characterBody.pendingTonicAfflictionCount++;
}
return true;
}
private bool FireCleanse()
{
Vector3 corePosition = characterBody.corePosition;
EffectData effectData = new EffectData
{
origin = corePosition
};
effectData.SetHurtBoxReference(characterBody.mainHurtBox);
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/CleanseEffect"), effectData, transmit: true);
Util.CleanseBody(characterBody, removeDebuffs: true, removeBuffs: false, removeCooldownBuffs: true, removeDots: true, removeStun: true, removeNearbyProjectiles: true);
return true;
}
private bool FireFireBallDash()
{
Ray aimRay = GetAimRay();
GameObject gameObject = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/FireballVehicle"), aimRay.origin, Quaternion.LookRotation(aimRay.direction));
gameObject.GetComponent<VehicleSeat>().AssignPassenger(base.gameObject);
NetworkUser networkUser = characterBody?.master?.playerCharacterMasterController?.networkUser;
if ((bool)networkUser)
{
NetworkServer.SpawnWithClientAuthority(gameObject, networkUser.gameObject);
}
else
{
NetworkServer.Spawn(gameObject);
}
subcooldownTimer = 2f;
return true;
}
private bool FireGainArmor()
{
characterBody.AddTimedBuff(RoR2Content.Buffs.ElephantArmorBoost, 5f);
return true;
}
private bool FireRecycle()
{
UpdateTargets(RoR2Content.Equipment.Recycle.equipmentIndex, userShouldAnticipateTarget: false);
GenericPickupController pickupController = currentTarget.pickupController;
if ((bool)pickupController && !pickupController.Recycled)
{
PickupIndex initialPickupIndex = pickupController.pickupIndex;
subcooldownTimer = 0.2f;
PickupIndex[] array = (from pickupIndex in PickupTransmutationManager.GetAvailableGroupFromPickupIndex(pickupController.pickupIndex)
where pickupIndex != initialPickupIndex
select pickupIndex).ToArray();
if (array == null)
{
return false;
}
if (array.Length == 0)
{
return false;
}
pickupController.NetworkpickupIndex = Run.instance.treasureRng.NextElementUniform(array);
EffectManager.SimpleEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/OmniEffect/OmniRecycleEffect"), pickupController.pickupDisplay.transform.position, Quaternion.identity, transmit: true);
pickupController.NetworkRecycled = true;
InvalidateCurrentTarget();
return true;
}
return false;
}
private bool FireGateway()
{
_ = characterBody.footPosition;
Ray aimRay = GetAimRay();
float num = 2f;
float num2 = num * 2f;
float maxDistance = 1000f;
Rigidbody component = GetComponent<Rigidbody>();
if (!component)
{
return false;
}
Vector3 position = base.transform.position;
if (Physics.Raycast(aimRay, out var hitInfo, maxDistance, LayerIndex.world.mask, QueryTriggerInteraction.Ignore))
{
Vector3 vector = hitInfo.point + hitInfo.normal * num;
Vector3 vector2 = vector - position;
Vector3 normalized = vector2.normalized;
Vector3 pointBPosition = vector;
if (component.SweepTest(normalized, out var hitInfo2, vector2.magnitude))
{
if (hitInfo2.distance < num2)
{
return false;
}
pointBPosition = position + normalized * hitInfo2.distance;
}
GameObject obj = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/Zipline"));
ZiplineController component2 = obj.GetComponent<ZiplineController>();
component2.SetPointAPosition(position + normalized * num);
component2.SetPointBPosition(pointBPosition);
obj.AddComponent<DestroyOnTimer>().duration = 30f;
NetworkServer.Spawn(obj);
return true;
}
return false;
}
private bool FireLifeStealOnHit()
{
EffectData effectData = new EffectData
{
origin = characterBody.corePosition
};
effectData.SetHurtBoxReference(characterBody.gameObject);
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/LifeStealOnHitActivation"), effectData, transmit: false);
characterBody.AddTimedBuff(RoR2Content.Buffs.LifeSteal, 8f);
return true;
}
private bool FireTeamWarCry()
{
Util.PlaySound("Play_teamWarCry_activate", characterBody.gameObject);
Vector3 corePosition = characterBody.corePosition;
EffectData effectData = new EffectData
{
origin = corePosition
};
effectData.SetNetworkedObjectReference(characterBody.gameObject);
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/TeamWarCryActivation"), effectData, transmit: true);
characterBody.AddTimedBuff(RoR2Content.Buffs.TeamWarCry, 7f);
TeamComponent[] array = UnityEngine.Object.FindObjectsOfType<TeamComponent>();
for (int i = 0; i < array.Length; i++)
{
if (array[i].teamIndex == teamComponent.teamIndex)
{
array[i].GetComponent<CharacterBody>().AddTimedBuff(RoR2Content.Buffs.TeamWarCry, 7f);
}
}
return true;
}
private bool FireDeathProjectile()
{
CharacterMaster master = characterBody.master;
if (!master)
{
return false;
}
if (master.IsDeployableLimited(DeployableSlot.DeathProjectile))
{
return false;
}
Ray aimRay = GetAimRay();
Quaternion rotation = Quaternion.LookRotation(aimRay.direction);
GameObject gameObject = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/DeathProjectile");
gameObject.GetComponent<DeathProjectile>().teamIndex = teamComponent.teamIndex;
FireProjectileInfo fireProjectileInfo = default(FireProjectileInfo);
fireProjectileInfo.projectilePrefab = gameObject;
fireProjectileInfo.crit = characterBody.RollCrit();
fireProjectileInfo.damage = characterBody.damage;
fireProjectileInfo.damageColorIndex = DamageColorIndex.Item;
fireProjectileInfo.force = 0f;
fireProjectileInfo.owner = base.gameObject;
fireProjectileInfo.position = aimRay.origin;
fireProjectileInfo.rotation = rotation;
FireProjectileInfo fireProjectileInfo2 = fireProjectileInfo;
ProjectileManager.instance.FireProjectile(fireProjectileInfo2);
return true;
}
private bool FireMolotov()
{
Ray aimRay = GetAimRay();
GameObject prefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/MolotovClusterProjectile");
ProjectileManager.instance.FireProjectile(prefab, aimRay.origin, Quaternion.LookRotation(aimRay.direction), base.gameObject, characterBody.damage, 0f, Util.CheckRoll(characterBody.crit, characterBody.master));
return true;
}
private bool FireVendingMachine()
{
Ray ray = new Ray(GetAimRay().origin, Vector3.down);
if (Util.CharacterRaycast(base.gameObject, ray, out var hitInfo, 1000f, LayerIndex.world.mask, QueryTriggerInteraction.UseGlobal))
{
GameObject prefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/VendingMachineProjectile");
ProjectileManager.instance.FireProjectile(prefab, hitInfo.point, Quaternion.identity, base.gameObject, characterBody.damage, 0f, Util.CheckRoll(characterBody.crit, characterBody.master));
subcooldownTimer = 0.5f;
return true;
}
return false;
}
private bool FireGummyClone()
{
CharacterMaster characterMaster = characterBody?.master;
if (!characterMaster || characterMaster.IsDeployableLimited(DeployableSlot.GummyClone))
{
return false;
}
Ray aimRay = GetAimRay();
Quaternion rotation = Quaternion.LookRotation(aimRay.direction);
GameObject projectilePrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/GummyCloneProjectile");
FireProjectileInfo fireProjectileInfo = default(FireProjectileInfo);
fireProjectileInfo.projectilePrefab = projectilePrefab;
fireProjectileInfo.crit = characterBody.RollCrit();
fireProjectileInfo.damage = 0f;
fireProjectileInfo.damageColorIndex = DamageColorIndex.Item;
fireProjectileInfo.force = 0f;
fireProjectileInfo.owner = base.gameObject;
fireProjectileInfo.position = aimRay.origin;
fireProjectileInfo.rotation = rotation;
FireProjectileInfo fireProjectileInfo2 = fireProjectileInfo;
ProjectileManager.instance.FireProjectile(fireProjectileInfo2);
return true;
}
private bool FireLunarPortalOnUse()
{
TeleporterInteraction.instance.shouldAttemptToSpawnShopPortal = true;
return true;
}
private bool FireHealAndRevive()
{
bool flag = false;
foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
{
CharacterMaster master = instance.master;
if (!instance.isConnected || !master.IsDeadAndOutOfLivesServer())
{
continue;
}
flag = true;
Vector3 deathFootPosition = master.deathFootPosition;
master.Respawn(deathFootPosition, Quaternion.Euler(0f, UnityEngine.Random.Range(0f, 360f), 0f));
CharacterBody body = master.GetBody();
if ((bool)body)
{
body.AddTimedBuff(RoR2Content.Buffs.Immune, 3f);
EntityStateMachine[] components = body.GetComponents<EntityStateMachine>();
foreach (EntityStateMachine obj in components)
{
obj.initialStateType = obj.mainStateType;
}
playerRespawnEffectPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/fxHealAndReviveGold");
if ((bool)playerRespawnEffectPrefab)
{
EffectManager.SpawnEffect(playerRespawnEffectPrefab, new EffectData
{
origin = deathFootPosition,
rotation = body.transform.rotation
}, transmit: true);
Util.PlaySound("Play_item_use_healAndRevive_activate", base.gameObject);
}
}
}
if (flag)
{
bool flag2 = false;
if (characterBody?.equipmentSlot != null && characterBody?.equipmentSlot.equipmentIndex == DLC2Content.Equipment.HealAndRevive.equipmentIndex)
{
flag2 = true;
}
if ((bool)characterBody?.inventory && flag2)
{
CharacterMasterNotificationQueue.SendTransformNotification(characterBody.master, characterBody.inventory.currentEquipmentIndex, DLC2Content.Equipment.HealAndReviveConsumed.equipmentIndex, CharacterMasterNotificationQueue.TransformationType.Default);
characterBody.inventory.SetEquipmentIndex(DLC2Content.Equipment.HealAndReviveConsumed.equipmentIndex);
}
}
if (!flag)
{
return false;
}
return true;
}
private bool FireSproutOfLife()
{
if (sproutIsSpawned && (bool)sprout)
{
sproutIsSpawned = false;
NetworkServer.Destroy(sprout);
}
Ray aimRay = GetAimRay();
Quaternion.LookRotation(aimRay.direction);
sproutSpawnTransform = characterBody.transform;
Vector3 position = characterBody.transform.position;
characterBody.transform.TransformDirection(Vector3.forward);
new Quaternion(0f, UnityEngine.Random.Range(0f, 360f), 0f, 1f);
if (Physics.Raycast(position, aimRay.direction, out var hitInfo, float.PositiveInfinity, LayerIndex.world.mask, QueryTriggerInteraction.Ignore))
{
sproutSpawnTransform.position = hitInfo.point;
sproutSpawnTransform.up = hitInfo.normal;
sprout = UnityEngine.Object.Instantiate(LegacyResourcesAPI.Load<GameObject>("Prefabs/SproutOfLifeHealing"), sproutSpawnTransform.position, Quaternion.identity);
sprout.transform.up = sproutSpawnTransform.up;
sprout.transform.rotation *= Quaternion.AngleAxis(UnityEngine.Random.Range(0f, 360f), Vector3.up);
NetworkServer.Spawn(sprout);
sproutIsSpawned = true;
return true;
}
return false;
}
static EquipmentSlot()
{
tonicBuffDuration = 20f;
equipmentActivateString = "Play_UI_equipment_activate";
activeParamHash = Animator.StringToHash("active");
activeDurationParamHash = Animator.StringToHash("activeDuration");
activeStopwatchParamHash = Animator.StringToHash("activeStopwatch");
kCmdCmdExecuteIfReady = -303452611;
NetworkBehaviour.RegisterCommandDelegate(typeof(EquipmentSlot), kCmdCmdExecuteIfReady, InvokeCmdCmdExecuteIfReady);
kCmdCmdOnEquipmentExecuted = 1725820338;
NetworkBehaviour.RegisterCommandDelegate(typeof(EquipmentSlot), kCmdCmdOnEquipmentExecuted, InvokeCmdCmdOnEquipmentExecuted);
kRpcRpcOnClientEquipmentActivationRecieved = 1342577121;
NetworkBehaviour.RegisterRpcDelegate(typeof(EquipmentSlot), kRpcRpcOnClientEquipmentActivationRecieved, InvokeRpcRpcOnClientEquipmentActivationRecieved);
NetworkCRC.RegisterBehaviour("EquipmentSlot", 0);
}
private void UNetVersion()
{
}
protected static void InvokeCmdCmdExecuteIfReady(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkServer.active)
{
Debug.LogError("Command CmdExecuteIfReady called on client.");
}
else
{
((EquipmentSlot)obj).CmdExecuteIfReady();
}
}
protected static void InvokeCmdCmdOnEquipmentExecuted(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkServer.active)
{
Debug.LogError("Command CmdOnEquipmentExecuted called on client.");
}
else
{
((EquipmentSlot)obj).CmdOnEquipmentExecuted();
}
}
public void CallCmdExecuteIfReady()
{
if (!NetworkClient.active)
{
Debug.LogError("Command function CmdExecuteIfReady called on server.");
return;
}
if (base.isServer)
{
CmdExecuteIfReady();
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)5);
networkWriter.WritePackedUInt32((uint)kCmdCmdExecuteIfReady);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendCommandInternal(networkWriter, 0, "CmdExecuteIfReady");
}
public void CallCmdOnEquipmentExecuted()
{
if (!NetworkClient.active)
{
Debug.LogError("Command function CmdOnEquipmentExecuted called on server.");
return;
}
if (base.isServer)
{
CmdOnEquipmentExecuted();
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)5);
networkWriter.WritePackedUInt32((uint)kCmdCmdOnEquipmentExecuted);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendCommandInternal(networkWriter, 0, "CmdOnEquipmentExecuted");
}
protected static void InvokeRpcRpcOnClientEquipmentActivationRecieved(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcOnClientEquipmentActivationRecieved called on server.");
}
else
{
((EquipmentSlot)obj).RpcOnClientEquipmentActivationRecieved();
}
}
public void CallRpcOnClientEquipmentActivationRecieved()
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcOnClientEquipmentActivationRecieved called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcOnClientEquipmentActivationRecieved);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendRPCInternal(networkWriter, 0, "RpcOnClientEquipmentActivationRecieved");
}
public override bool OnSerialize(NetworkWriter writer, bool forceAll)
{
bool result = default(bool);
return result;
}
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
}
public override void PreStartClient()
{
}
}