r2mods/ilspy_dump/ror2_csproj/RoR2/SetStateOnHurt.cs

500 lines
12 KiB
C#
Raw Normal View History

2024-10-04 07:26:37 +00:00
using EntityStates;
using UnityEngine;
using UnityEngine.Networking;
namespace RoR2;
[DisallowMultipleComponent]
public class SetStateOnHurt : NetworkBehaviour, IOnTakeDamageServerReceiver
{
[Tooltip("The percentage of their max HP they need to take to get stunned. Ranges from 0-1.")]
public float hitThreshold = 0.1f;
[Tooltip("The state machine to set the state of when this character is hurt.")]
public EntityStateMachine targetStateMachine;
[Tooltip("The state machine to set to idle when this character is hurt.")]
public EntityStateMachine[] idleStateMachine;
[Tooltip("The state to enter when this character is hurt.")]
public SerializableEntityStateType hurtState;
public bool canBeHitStunned = true;
public bool canBeStunned = true;
public bool canBeFrozen = true;
private bool hasEffectiveAuthority = true;
private static readonly float stunChanceOnHitBaseChancePercent;
private static int kRpcRpcSetStun;
private static int kRpcRpcSetFrozen;
private static int kRpcRpcSetShock;
private static int kRpcRpcSetPain;
private static int kRpcRpcCleanse;
private bool spawnedOverNetwork => base.isServer;
public static void SetStunOnObject(GameObject target, float duration)
{
SetStateOnHurt component = target.GetComponent<SetStateOnHurt>();
if ((bool)component)
{
component.SetStun(duration);
}
}
public override void OnStartAuthority()
{
base.OnStartAuthority();
UpdateAuthority();
}
public override void OnStopAuthority()
{
base.OnStopAuthority();
UpdateAuthority();
}
private void UpdateAuthority()
{
hasEffectiveAuthority = Util.HasEffectiveAuthority(base.gameObject);
}
private void Start()
{
UpdateAuthority();
}
public void OnTakeDamageServer(DamageReport damageReport)
{
if (!targetStateMachine || !spawnedOverNetwork)
{
return;
}
HealthComponent victim = damageReport.victim;
DamageInfo damageInfo = damageReport.damageInfo;
CharacterMaster attackerMaster = damageReport.attackerMaster;
int num = (attackerMaster ? attackerMaster.inventory.GetItemCount(RoR2Content.Items.StunChanceOnHit) : 0);
if (num > 0 && Util.CheckRoll(Util.ConvertAmplificationPercentageIntoReductionPercentage(stunChanceOnHitBaseChancePercent * (float)num * damageReport.damageInfo.procCoefficient), attackerMaster))
{
EffectManager.SimpleImpactEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/ImpactEffects/ImpactStunGrenade"), damageInfo.position, -damageInfo.force, transmit: true);
SetStun(2f);
}
bool flag = damageInfo.procCoefficient >= Mathf.Epsilon;
float damageDealt = damageReport.damageDealt;
if (flag && canBeFrozen && (ulong)(damageInfo.damageType & DamageType.Freeze2s) != 0L)
{
SetFrozen(2f * damageInfo.procCoefficient);
}
else if (!victim.isInFrozenState)
{
if (flag && canBeStunned && (ulong)(damageInfo.damageType & DamageType.Shock5s) != 0L)
{
SetShock(5f * damageReport.damageInfo.procCoefficient);
}
else if (flag && canBeStunned && (ulong)(damageInfo.damageType & DamageType.Stun1s) != 0L)
{
SetStun(1f);
}
else if (canBeHitStunned && damageDealt > victim.fullCombinedHealth * hitThreshold)
{
SetPain();
}
}
}
[Server]
public void SetStun(float duration)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.SetStateOnHurt::SetStun(System.Single)' called on client");
}
else if (canBeStunned)
{
if (hasEffectiveAuthority)
{
SetStunInternal(duration);
}
else
{
CallRpcSetStun(duration);
}
}
}
[Server]
public void SetFrozen(float duration)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.SetStateOnHurt::SetFrozen(System.Single)' called on client");
}
else if (canBeFrozen)
{
if (hasEffectiveAuthority)
{
SetFrozenInternal(duration);
}
else
{
CallRpcSetFrozen(duration);
}
}
}
[Server]
public void SetShock(float duration)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.SetStateOnHurt::SetShock(System.Single)' called on client");
}
else if (canBeStunned)
{
if (hasEffectiveAuthority)
{
SetShockInternal(duration);
}
else
{
CallRpcSetShock(duration);
}
}
}
[Server]
public void SetPain()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.SetStateOnHurt::SetPain()' called on client");
}
else if (canBeHitStunned)
{
if (hasEffectiveAuthority)
{
SetPainInternal();
}
else
{
CallRpcSetPain();
}
}
}
[Server]
public void Cleanse()
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.SetStateOnHurt::Cleanse()' called on client");
}
else if (hasEffectiveAuthority)
{
CleanseInternal();
}
else
{
CallRpcCleanse();
}
}
[ClientRpc]
private void RpcSetStun(float duration)
{
if (hasEffectiveAuthority)
{
SetStunInternal(duration);
}
}
private void SetStunInternal(float duration)
{
if ((bool)targetStateMachine)
{
if (targetStateMachine.state is StunState)
{
(targetStateMachine.state as StunState).ExtendStun(duration);
}
else
{
StunState stunState = new StunState();
stunState.stunDuration = duration;
targetStateMachine.SetInterruptState(stunState, InterruptPriority.Stun);
}
}
EntityStateMachine[] array = idleStateMachine;
for (int i = 0; i < array.Length; i++)
{
array[i].SetNextStateToMain();
}
}
[ClientRpc]
private void RpcSetFrozen(float duration)
{
if (hasEffectiveAuthority)
{
SetFrozenInternal(duration);
}
}
private void SetFrozenInternal(float duration)
{
if ((bool)targetStateMachine)
{
FrozenState frozenState = new FrozenState();
frozenState.freezeDuration = duration;
targetStateMachine.SetInterruptState(frozenState, InterruptPriority.Frozen);
}
EntityStateMachine[] array = idleStateMachine;
for (int i = 0; i < array.Length; i++)
{
array[i].SetNextState(new Idle());
}
}
[ClientRpc]
private void RpcSetShock(float duration)
{
if (hasEffectiveAuthority)
{
SetShockInternal(duration);
}
}
private void SetShockInternal(float duration)
{
if ((bool)targetStateMachine)
{
ShockState shockState = new ShockState();
shockState.shockDuration = duration;
targetStateMachine.SetInterruptState(shockState, InterruptPriority.Pain);
}
EntityStateMachine[] array = idleStateMachine;
for (int i = 0; i < array.Length; i++)
{
array[i].SetNextStateToMain();
}
}
[ClientRpc]
private void RpcSetPain()
{
if (hasEffectiveAuthority)
{
SetPainInternal();
}
}
private void SetPainInternal()
{
if ((bool)targetStateMachine)
{
targetStateMachine.SetInterruptState(EntityStateCatalog.InstantiateState(ref hurtState), InterruptPriority.Pain);
}
EntityStateMachine[] array = idleStateMachine;
for (int i = 0; i < array.Length; i++)
{
array[i].SetNextStateToMain();
}
}
[ClientRpc]
private void RpcCleanse()
{
if (hasEffectiveAuthority)
{
CleanseInternal();
}
}
private void CleanseInternal()
{
if ((bool)targetStateMachine && (targetStateMachine.state is FrozenState || targetStateMachine.state is StunState || targetStateMachine.state is ShockState))
{
targetStateMachine.SetInterruptState(EntityStateCatalog.InstantiateState(ref targetStateMachine.mainStateType), InterruptPriority.Frozen);
}
}
static SetStateOnHurt()
{
stunChanceOnHitBaseChancePercent = 5f;
kRpcRpcSetStun = 788834249;
NetworkBehaviour.RegisterRpcDelegate(typeof(SetStateOnHurt), kRpcRpcSetStun, InvokeRpcRpcSetStun);
kRpcRpcSetFrozen = 1781279215;
NetworkBehaviour.RegisterRpcDelegate(typeof(SetStateOnHurt), kRpcRpcSetFrozen, InvokeRpcRpcSetFrozen);
kRpcRpcSetShock = -1316305549;
NetworkBehaviour.RegisterRpcDelegate(typeof(SetStateOnHurt), kRpcRpcSetShock, InvokeRpcRpcSetShock);
kRpcRpcSetPain = 788726245;
NetworkBehaviour.RegisterRpcDelegate(typeof(SetStateOnHurt), kRpcRpcSetPain, InvokeRpcRpcSetPain);
kRpcRpcCleanse = -339360280;
NetworkBehaviour.RegisterRpcDelegate(typeof(SetStateOnHurt), kRpcRpcCleanse, InvokeRpcRpcCleanse);
NetworkCRC.RegisterBehaviour("SetStateOnHurt", 0);
}
private void UNetVersion()
{
}
protected static void InvokeRpcRpcSetStun(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcSetStun called on server.");
}
else
{
((SetStateOnHurt)obj).RpcSetStun(reader.ReadSingle());
}
}
protected static void InvokeRpcRpcSetFrozen(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcSetFrozen called on server.");
}
else
{
((SetStateOnHurt)obj).RpcSetFrozen(reader.ReadSingle());
}
}
protected static void InvokeRpcRpcSetShock(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcSetShock called on server.");
}
else
{
((SetStateOnHurt)obj).RpcSetShock(reader.ReadSingle());
}
}
protected static void InvokeRpcRpcSetPain(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcSetPain called on server.");
}
else
{
((SetStateOnHurt)obj).RpcSetPain();
}
}
protected static void InvokeRpcRpcCleanse(NetworkBehaviour obj, NetworkReader reader)
{
if (!NetworkClient.active)
{
Debug.LogError("RPC RpcCleanse called on server.");
}
else
{
((SetStateOnHurt)obj).RpcCleanse();
}
}
public void CallRpcSetStun(float duration)
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcSetStun called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcSetStun);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
networkWriter.Write(duration);
SendRPCInternal(networkWriter, 0, "RpcSetStun");
}
public void CallRpcSetFrozen(float duration)
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcSetFrozen called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcSetFrozen);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
networkWriter.Write(duration);
SendRPCInternal(networkWriter, 0, "RpcSetFrozen");
}
public void CallRpcSetShock(float duration)
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcSetShock called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcSetShock);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
networkWriter.Write(duration);
SendRPCInternal(networkWriter, 0, "RpcSetShock");
}
public void CallRpcSetPain()
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcSetPain called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcSetPain);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendRPCInternal(networkWriter, 0, "RpcSetPain");
}
public void CallRpcCleanse()
{
if (!NetworkServer.active)
{
Debug.LogError("RPC Function RpcCleanse called on client.");
return;
}
NetworkWriter networkWriter = new NetworkWriter();
networkWriter.Write((short)0);
networkWriter.Write((short)2);
networkWriter.WritePackedUInt32((uint)kRpcRpcCleanse);
networkWriter.Write(GetComponent<NetworkIdentity>().netId);
SendRPCInternal(networkWriter, 0, "RpcCleanse");
}
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()
{
}
}