389 lines
9.3 KiB
C#
389 lines
9.3 KiB
C#
using System.Runtime.CompilerServices;
|
|
using HG;
|
|
using JetBrains.Annotations;
|
|
using RoR2.Audio;
|
|
using UnityEngine;
|
|
using UnityEngine.Networking;
|
|
|
|
namespace RoR2;
|
|
|
|
public class EffectData
|
|
{
|
|
private Vector3 _origin;
|
|
|
|
public Quaternion rotation = defaultRotation;
|
|
|
|
public float scale = defaultScale;
|
|
|
|
public Color32 color = defaultColor;
|
|
|
|
public Vector3 start = defaultStart;
|
|
|
|
public SurfaceDefIndex surfaceDefIndex = defaultSurfaceDefIndex;
|
|
|
|
public uint genericUInt = defaultGenericUInt;
|
|
|
|
public float genericFloat = defaultGenericFloat;
|
|
|
|
public bool genericBool = defaultGenericBool;
|
|
|
|
public NetworkSoundEventIndex networkSoundEventIndex = defaultNetworkSoundEventIndex;
|
|
|
|
private static readonly uint useNonDefaultRotationFlag = 1u;
|
|
|
|
private static readonly uint useNonDefaultRootObjectFlag = 2u;
|
|
|
|
private static readonly uint useNonDefaultModelChildIndexFlag = 4u;
|
|
|
|
private static readonly uint useNonDefaultScaleFlag = 8u;
|
|
|
|
private static readonly uint useNonDefaultColorFlag = 16u;
|
|
|
|
private static readonly uint useNonDefaultStartFlag = 32u;
|
|
|
|
private static readonly uint useNonDefaultSurfaceDefIndexFlag = 64u;
|
|
|
|
private static readonly uint useNonDefaultGenericUIntFlag = 128u;
|
|
|
|
private static readonly uint useNonDefaultGenericFloatFlag = 256u;
|
|
|
|
private static readonly uint useNonDefaultGenericBoolFlag = 512u;
|
|
|
|
private static readonly uint useNonDefaultNetworkSoundEventIndexFlag = 1024u;
|
|
|
|
private static readonly Quaternion defaultRotation = Quaternion.identity;
|
|
|
|
private static readonly GameObject defaultRootObject = null;
|
|
|
|
private static readonly short defaultModelChildIndex = -1;
|
|
|
|
private static readonly float defaultScale = 1f;
|
|
|
|
private static readonly Color32 defaultColor = Color.white;
|
|
|
|
private static readonly Vector3 defaultStart = Vector3.zero;
|
|
|
|
private static readonly SurfaceDefIndex defaultSurfaceDefIndex = SurfaceDefIndex.Invalid;
|
|
|
|
private static readonly uint defaultGenericUInt = 0u;
|
|
|
|
private static readonly float defaultGenericFloat = 0f;
|
|
|
|
private static readonly bool defaultGenericBool = false;
|
|
|
|
public bool forceUnpooled;
|
|
|
|
private static readonly NetworkSoundEventIndex defaultNetworkSoundEventIndex = NetworkSoundEventIndex.Invalid;
|
|
|
|
public Vector3 origin
|
|
{
|
|
get
|
|
{
|
|
return _origin;
|
|
}
|
|
set
|
|
{
|
|
if (!Util.PositionIsValid(value))
|
|
{
|
|
Debug.LogFormat("EffectData.origin assignment position is invalid! Position={0}", value);
|
|
}
|
|
else
|
|
{
|
|
_origin = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public GameObject rootObject { get; private set; } = defaultRootObject;
|
|
|
|
|
|
public short modelChildIndex { get; private set; } = defaultModelChildIndex;
|
|
|
|
|
|
public static void Copy([NotNull] EffectData src, [NotNull] EffectData dest)
|
|
{
|
|
dest.origin = src.origin;
|
|
dest.rotation = src.rotation;
|
|
dest.rootObject = src.rootObject;
|
|
dest.modelChildIndex = src.modelChildIndex;
|
|
dest.scale = src.scale;
|
|
dest.color = src.color;
|
|
dest.start = src.start;
|
|
dest.surfaceDefIndex = src.surfaceDefIndex;
|
|
dest.genericUInt = src.genericUInt;
|
|
dest.genericFloat = src.genericFloat;
|
|
dest.genericBool = src.genericBool;
|
|
dest.networkSoundEventIndex = src.networkSoundEventIndex;
|
|
dest.forceUnpooled = src.forceUnpooled;
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
_origin = Vector3.zero;
|
|
rotation = Quaternion.identity;
|
|
rootObject = null;
|
|
modelChildIndex = -1;
|
|
scale = 1f;
|
|
color = Color.white;
|
|
start = Vector3.zero;
|
|
genericUInt = 0u;
|
|
genericFloat = 0f;
|
|
genericBool = false;
|
|
forceUnpooled = false;
|
|
}
|
|
|
|
public void SetNetworkedObjectReference(GameObject networkedObject)
|
|
{
|
|
rootObject = networkedObject;
|
|
modelChildIndex = -1;
|
|
}
|
|
|
|
public GameObject ResolveNetworkedObjectReference()
|
|
{
|
|
return rootObject;
|
|
}
|
|
|
|
public void SetHurtBoxReference(HurtBox hurtBox)
|
|
{
|
|
if (!hurtBox || !hurtBox.healthComponent)
|
|
{
|
|
rootObject = null;
|
|
modelChildIndex = -1;
|
|
}
|
|
else
|
|
{
|
|
rootObject = hurtBox.healthComponent.gameObject;
|
|
modelChildIndex = hurtBox.indexInGroup;
|
|
}
|
|
}
|
|
|
|
public void SetHurtBoxReference(GameObject gameObject)
|
|
{
|
|
HurtBox hurtBox = gameObject?.GetComponent<HurtBox>();
|
|
if ((bool)hurtBox)
|
|
{
|
|
SetHurtBoxReference(hurtBox);
|
|
return;
|
|
}
|
|
rootObject = gameObject;
|
|
modelChildIndex = -1;
|
|
}
|
|
|
|
public GameObject ResolveHurtBoxReference()
|
|
{
|
|
if (modelChildIndex == -1)
|
|
{
|
|
return rootObject;
|
|
}
|
|
if (!rootObject)
|
|
{
|
|
return null;
|
|
}
|
|
ModelLocator component = rootObject.GetComponent<ModelLocator>();
|
|
if (!component)
|
|
{
|
|
return null;
|
|
}
|
|
Transform modelTransform = component.modelTransform;
|
|
if (!modelTransform)
|
|
{
|
|
return null;
|
|
}
|
|
HurtBoxGroup component2 = modelTransform.GetComponent<HurtBoxGroup>();
|
|
if (!component2)
|
|
{
|
|
return null;
|
|
}
|
|
HurtBox safe = ArrayUtils.GetSafe(component2.hurtBoxes, modelChildIndex);
|
|
if (!safe)
|
|
{
|
|
return null;
|
|
}
|
|
return safe.gameObject;
|
|
}
|
|
|
|
public void SetChildLocatorTransformReference(GameObject rootObject, int childIndex)
|
|
{
|
|
this.rootObject = rootObject;
|
|
modelChildIndex = (short)childIndex;
|
|
}
|
|
|
|
public Transform ResolveChildLocatorTransformReference()
|
|
{
|
|
if ((bool)rootObject)
|
|
{
|
|
if (modelChildIndex == -1)
|
|
{
|
|
return rootObject.transform;
|
|
}
|
|
ModelLocator component = rootObject.GetComponent<ModelLocator>();
|
|
if ((bool)component && (bool)component.modelTransform)
|
|
{
|
|
ChildLocator component2 = component.modelTransform.GetComponent<ChildLocator>();
|
|
if ((bool)component2)
|
|
{
|
|
return component2.FindChild(modelChildIndex);
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public EffectData Clone()
|
|
{
|
|
EffectData effectData = new EffectData();
|
|
Copy(this, effectData);
|
|
return effectData;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static bool ColorEquals(in Color32 x, in Color32 y)
|
|
{
|
|
if (x.r == y.r && x.g == y.g && x.b == y.b)
|
|
{
|
|
return x.a == y.a;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void Serialize(NetworkWriter writer)
|
|
{
|
|
uint num = 0u;
|
|
bool num2 = !rotation.Equals(defaultRotation);
|
|
bool flag = rootObject != defaultRootObject;
|
|
bool flag2 = modelChildIndex != defaultModelChildIndex;
|
|
bool flag3 = scale != defaultScale;
|
|
bool flag4 = !ColorEquals(in color, in defaultColor);
|
|
bool flag5 = !start.Equals(defaultStart);
|
|
bool flag6 = surfaceDefIndex != defaultSurfaceDefIndex;
|
|
bool flag7 = genericUInt != defaultGenericUInt;
|
|
bool flag8 = genericFloat != defaultGenericFloat;
|
|
bool flag9 = genericBool != defaultGenericBool;
|
|
bool flag10 = networkSoundEventIndex != defaultNetworkSoundEventIndex;
|
|
if (num2)
|
|
{
|
|
num |= useNonDefaultRotationFlag;
|
|
}
|
|
if (flag)
|
|
{
|
|
num |= useNonDefaultRootObjectFlag;
|
|
}
|
|
if (flag2)
|
|
{
|
|
num |= useNonDefaultModelChildIndexFlag;
|
|
}
|
|
if (flag3)
|
|
{
|
|
num |= useNonDefaultScaleFlag;
|
|
}
|
|
if (flag4)
|
|
{
|
|
num |= useNonDefaultColorFlag;
|
|
}
|
|
if (flag5)
|
|
{
|
|
num |= useNonDefaultStartFlag;
|
|
}
|
|
if (flag6)
|
|
{
|
|
num |= useNonDefaultSurfaceDefIndexFlag;
|
|
}
|
|
if (flag7)
|
|
{
|
|
num |= useNonDefaultGenericUIntFlag;
|
|
}
|
|
if (flag8)
|
|
{
|
|
num |= useNonDefaultGenericFloatFlag;
|
|
}
|
|
if (flag9)
|
|
{
|
|
num |= useNonDefaultGenericBoolFlag;
|
|
}
|
|
if (flag10)
|
|
{
|
|
num |= useNonDefaultNetworkSoundEventIndexFlag;
|
|
}
|
|
writer.WritePackedUInt32(num);
|
|
writer.Write(origin);
|
|
if (num2)
|
|
{
|
|
writer.Write(rotation);
|
|
}
|
|
if (flag)
|
|
{
|
|
writer.Write(rootObject);
|
|
}
|
|
if (flag2)
|
|
{
|
|
writer.Write((byte)(modelChildIndex + 1));
|
|
}
|
|
if (flag3)
|
|
{
|
|
writer.Write(scale);
|
|
}
|
|
if (flag4)
|
|
{
|
|
writer.Write(color);
|
|
}
|
|
if (flag5)
|
|
{
|
|
writer.Write(start);
|
|
}
|
|
if (flag6)
|
|
{
|
|
writer.WritePackedIndex32((int)surfaceDefIndex);
|
|
}
|
|
if (flag7)
|
|
{
|
|
writer.WritePackedUInt32(genericUInt);
|
|
}
|
|
if (flag8)
|
|
{
|
|
writer.Write(genericFloat);
|
|
}
|
|
if (flag9)
|
|
{
|
|
writer.Write(genericBool);
|
|
}
|
|
if (flag10)
|
|
{
|
|
writer.WriteNetworkSoundEventIndex(networkSoundEventIndex);
|
|
}
|
|
writer.Write(forceUnpooled);
|
|
}
|
|
|
|
public void Deserialize(NetworkReader reader)
|
|
{
|
|
uint flags = reader.ReadPackedUInt32();
|
|
bool flag = HasFlag(in useNonDefaultRotationFlag);
|
|
bool flag2 = HasFlag(in useNonDefaultRootObjectFlag);
|
|
bool flag3 = HasFlag(in useNonDefaultModelChildIndexFlag);
|
|
bool flag4 = HasFlag(in useNonDefaultScaleFlag);
|
|
bool flag5 = HasFlag(in useNonDefaultColorFlag);
|
|
bool flag6 = HasFlag(in useNonDefaultStartFlag);
|
|
bool flag7 = HasFlag(in useNonDefaultSurfaceDefIndexFlag);
|
|
bool flag8 = HasFlag(in useNonDefaultGenericUIntFlag);
|
|
bool flag9 = HasFlag(in useNonDefaultGenericFloatFlag);
|
|
bool flag10 = HasFlag(in useNonDefaultGenericBoolFlag);
|
|
bool flag11 = HasFlag(in useNonDefaultNetworkSoundEventIndexFlag);
|
|
origin = reader.ReadVector3();
|
|
rotation = (flag ? reader.ReadQuaternion() : defaultRotation);
|
|
rootObject = (flag2 ? reader.ReadGameObject() : defaultRootObject);
|
|
modelChildIndex = (flag3 ? ((short)(reader.ReadByte() - 1)) : defaultModelChildIndex);
|
|
scale = (flag4 ? reader.ReadSingle() : defaultScale);
|
|
color = (flag5 ? reader.ReadColor32() : defaultColor);
|
|
start = (flag6 ? reader.ReadVector3() : defaultStart);
|
|
surfaceDefIndex = (flag7 ? ((SurfaceDefIndex)reader.ReadPackedIndex32()) : defaultSurfaceDefIndex);
|
|
genericUInt = (flag8 ? reader.ReadPackedUInt32() : defaultGenericUInt);
|
|
genericFloat = (flag9 ? reader.ReadSingle() : defaultGenericFloat);
|
|
genericBool = (flag10 ? reader.ReadBoolean() : defaultGenericBool);
|
|
networkSoundEventIndex = (flag11 ? reader.ReadNetworkSoundEventIndex() : defaultNetworkSoundEventIndex);
|
|
forceUnpooled = reader.ReadBoolean();
|
|
bool HasFlag(in uint mask)
|
|
{
|
|
return (flags & mask) != 0;
|
|
}
|
|
}
|
|
}
|