// Token: 0x06004D93 RID: 19859 RVA: 0x001A06F0 File Offset: 0x0019EAF0
private void SetupTriggers()
{
VRC_Trigger vrc_Trigger = base.GetComponent <VRC_Trigger>();
if (vrc_Trigger == null)
{
vrc_Trigger = base.gameObject.AddComponent <VRC_Trigger>();
}
VRC_Trigger.TriggerEvent triggerEvent = new VRC_Trigger.TriggerEvent();
triggerEvent.TriggerType = VRC_Trigger.TriggerType.OnPickup;
triggerEvent.BroadcastType = VRC_EventHandler.VrcBroadcastType.AlwaysUnbuffered;
VRC_EventHandler.VrcEvent vrcEvent = new VRC_EventHandler.VrcEvent();
vrcEvent.EventType = VRC_EventHandler.VrcEventType.SendRPC;
vrcEvent.ParameterObjects = new GameObject[1];
vrcEvent.ParameterObjects[0] = base.gameObject;
vrcEvent.ParameterString = "OnPickedUp";
vrcEvent.ParameterInt = 0;
vrcEvent.ParameterBytes = VRC_Serialization.ParameterEncoder(new object[0]);
triggerEvent.Events.Add(vrcEvent);
vrc_Trigger.Triggers.Add(triggerEvent);
VRC_Trigger.TriggerEvent triggerEvent2 = new VRC_Trigger.TriggerEvent();
triggerEvent2.TriggerType = VRC_Trigger.TriggerType.OnDrop;
triggerEvent2.BroadcastType = VRC_EventHandler.VrcBroadcastType.AlwaysUnbuffered;
VRC_EventHandler.VrcEvent vrcEvent2 = new VRC_EventHandler.VrcEvent();
vrcEvent2.EventType = VRC_EventHandler.VrcEventType.SendRPC;
vrcEvent2.ParameterObjects = new GameObject[1];
vrcEvent2.ParameterObjects[0] = base.gameObject;
vrcEvent2.ParameterString = "OnDropped";
vrcEvent2.ParameterInt = 0;
vrcEvent2.ParameterBytes = VRC_Serialization.ParameterEncoder(new object[0]);
triggerEvent2.Events.Add(vrcEvent2);
vrc_Trigger.Triggers.Add(triggerEvent2);
}
// Token: 0x06005A00 RID: 23040 RVA: 0x001F4A64 File Offset: 0x001F2E64
public static bool Deserialize(VRC_DataStorage.VrcDataElement ds, out object obj)
{
obj = null;
switch (ds.type)
{
case VRC_DataStorage.VrcDataType.None:
obj = null;
return(true);
case VRC_DataStorage.VrcDataType.Bool:
obj = ds.valueBool;
return(true);
case VRC_DataStorage.VrcDataType.Int:
obj = ds.valueInt;
return(true);
case VRC_DataStorage.VrcDataType.Float:
obj = ds.valueFloat;
return(true);
case VRC_DataStorage.VrcDataType.String:
obj = ds.valueString;
return(true);
case VRC_DataStorage.VrcDataType.SerializeBytes:
obj = ds.valueSerializedBytes;
return(true);
case VRC_DataStorage.VrcDataType.SerializeObject:
if (ds.serializeComponent == null)
{
return(false);
}
ds.serializeComponent.SetBytes(ds.valueSerializedBytes);
return(true);
case VRC_DataStorage.VrcDataType.Other:
{
object[] array = VRC_Serialization.ParameterDecoder(ds.valueSerializedBytes, false);
obj = ((array != null && array.Length != 0) ? array[0] : null);
return(true);
}
default:
Debug.LogError("Unable to handle " + ds.type.ToString());
return(false);
}
}
// Token: 0x060059FF RID: 23039 RVA: 0x001F4950 File Offset: 0x001F2D50
public static bool Serialize(VRC_DataStorage.VrcDataElement ds, object objectToStore)
{
ds.added = (ds.type == VRC_DataStorage.VrcDataType.None);
ds.modified = true;
if (objectToStore is bool)
{
ds.valueBool = (bool)objectToStore;
ds.type = VRC_DataStorage.VrcDataType.Bool;
return(true);
}
if (objectToStore is int)
{
ds.valueInt = (int)objectToStore;
ds.type = VRC_DataStorage.VrcDataType.Int;
return(true);
}
if (objectToStore is float)
{
ds.valueFloat = (float)objectToStore;
ds.type = VRC_DataStorage.VrcDataType.Float;
return(true);
}
if (objectToStore is string)
{
ds.valueString = (string)objectToStore;
ds.type = VRC_DataStorage.VrcDataType.String;
return(true);
}
if (objectToStore is byte[])
{
ds.valueSerializedBytes = (byte[])objectToStore;
ds.type = VRC_DataStorage.VrcDataType.SerializeBytes;
return(true);
}
if (objectToStore is VRC_SerializableBehaviour)
{
ds.serializeComponent = (VRC_SerializableBehaviour)objectToStore;
ds.valueSerializedBytes = ((VRC_SerializableBehaviour)objectToStore).GetBytes();
ds.type = VRC_DataStorage.VrcDataType.SerializeObject;
return(true);
}
ds.valueSerializedBytes = VRC_Serialization.ParameterEncoder(new object[]
{
objectToStore
});
ds.type = VRC_DataStorage.VrcDataType.Other;
return(true);
}
// Token: 0x060059F4 RID: 23028 RVA: 0x001F3E1C File Offset: 0x001F221C
public void CheckConsistency()
{
if (this.dataStorage.data.Length == 0 || this.timeOfNextConsistencyCheck - Time.time > 0f)
{
return;
}
this.timeOfNextConsistencyCheck = Time.time + UnityEngine.Random.Range(1f, 2f);
if (this.dataHash != null && this.dataHash.Length != this.dataStorage.data.Length)
{
this.dataHash = null;
}
if (this.dataHash == null)
{
this.dataHash = new SHA1[this.dataStorage.data.Length];
}
for (int i = 0; i < this.dataHash.Length; i++)
{
if (this.dataStorage.data[i].modified)
{
this.dataHash[i] = null;
}
SHA1 sha = SHA1.Create();
sha.ComputeHash(VRC_Serialization.ParameterEncoder(new object[]
{
this.dataStorage.data[i]
}));
bool flag = this.dataHash[i] == null || sha.HashSize != this.dataHash[i].HashSize || sha.Hash.Length != this.dataHash[i].Hash.Length;
if (!flag)
{
for (int j = 0; j < sha.Hash.Length; j++)
{
flag = (sha.Hash[j] != this.dataHash[i].Hash[j]);
if (flag)
{
break;
}
}
}
if (flag)
{
this.dataStorage.data[i].modified = flag;
this.dataHash[i] = sha;
base.photonView.lastOnSerializeDataSent = null;
}
}
}
private static void HandleTriggerPhysicsEvent(VRC_EventHandler.VrcEvent triggerEvent, GameObject obj)
{
object[] parameters = VRC_Serialization.ParameterDecoder(triggerEvent.ParameterBytes);
if (parameters.Length == 0)
{
parameters = new object[1] {
new Vector4()
};
}
Vector4 vec = (Vector4)parameters[0];
Vector3 vel = vec;
if (vec.w < .5f)
{
vel = obj.transform.TransformVector(vel);
}
Rigidbody rigidbody = obj.GetComponent <Rigidbody>();
if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetAngularVelocity)
{
rigidbody.angularVelocity = vel;
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AddAngularVelocity)
{
rigidbody.angularVelocity += vel;
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetVelocity)
{
rigidbody.velocity = vel;
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AddVelocity)
{
rigidbody.velocity += vel;
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AddForce)
{
rigidbody.AddForce(vel);
}
}
bool missingTeleportTo(VRC_Trigger trigger)
{
var emptyTeleport = false;
trigger.Triggers
.ForEach(t => {
t.Events.ForEach(e =>
{
if (e.EventType == VRC_EventHandler.VrcEventType.SendRPC && e.ParameterString == "TeleportTo")
{
object[] param = VRC_Serialization.ParameterDecoder(e.ParameterBytes);
if (param.Length < 1 || param[0] == null)
{
emptyTeleport = true;
}
}
});
});
return(emptyTeleport);
}
private static void ExecuteEventForObject(VRC_EventHandler.VrcEvent triggerEvent, GameObject obj, VRC_EventHandler.EventInfo eventInfo, VRC_Trigger.TriggerEvent originalTrigger)
{
instance_.Log("Executing Trigger Event: " + triggerEvent.GetEventAsString(obj) + "\n_On Trigger: " + originalTrigger?.GetTriggerEventAsString());
bool isBufferedExecution = eventInfo.broadcast.IsBufferedBroadcastType() && eventInfo.instagator == null;
if (eventInfo.broadcast.IsOwnerBroadcastType())
{
if (!Networking.IsOwner(obj) || isBufferedExecution)
{
instance_.LogWarning("Not executing as user is not the owner");
return;
}
}
if (!isBufferedExecution && eventInfo.broadcast.IsMasterBroadcastType())
{
if (!Networking.IsMaster || isBufferedExecution)
{
instance_.LogWarning("Not executing as user is not the master");
return;
}
}
if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.ActivateCustomTrigger)
{
// Only activates first one
VRC_Trigger trigger = obj.GetComponent <VRC_Trigger>();
if (obj.activeInHierarchy && trigger.enabled)
{
trigger.ExecuteCustomTrigger(triggerEvent.ParameterString);
}
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AnimationBool)
{
Animator animator = obj.GetComponent <Animator>();
bool value = animator.GetBool(triggerEvent.ParameterString);
bool newValue = VRC_EventHandler.BooleanOp(triggerEvent.ParameterBoolOp, value);
animator.SetBool(triggerEvent.ParameterString, newValue);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AnimationInt)
{
Animator animator = obj.GetComponent <Animator>();
animator.SetInteger(triggerEvent.ParameterString, triggerEvent.ParameterInt);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AnimationFloat)
{
Animator animator = obj.GetComponent <Animator>();
animator.SetFloat(triggerEvent.ParameterString, triggerEvent.ParameterFloat);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AnimationIntAdd)
{
Animator animator = obj.GetComponent <Animator>();
int value = animator.GetInteger(triggerEvent.ParameterString);
animator.SetInteger(triggerEvent.ParameterString, value + triggerEvent.ParameterInt);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AnimationIntDivide)
{
Animator animator = obj.GetComponent <Animator>();
int value = animator.GetInteger(triggerEvent.ParameterString);
animator.SetInteger(triggerEvent.ParameterString, value / triggerEvent.ParameterInt);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AnimationIntMultiply)
{
Animator animator = obj.GetComponent <Animator>();
int value = animator.GetInteger(triggerEvent.ParameterString);
animator.SetInteger(triggerEvent.ParameterString, value * triggerEvent.ParameterInt);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AnimationIntSubtract)
{
Animator animator = obj.GetComponent <Animator>();
int value = animator.GetInteger(triggerEvent.ParameterString);
animator.SetInteger(triggerEvent.ParameterString, value - triggerEvent.ParameterInt);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AnimationTrigger)
{
obj.GetComponent <Animator>().SetTrigger(triggerEvent.ParameterString);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.PlayAnimation)
{
obj.GetComponent <Animation>().Play(triggerEvent.ParameterString);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AudioTrigger)
{
AudioSource[] audioSources = obj.GetComponents <AudioSource>();
foreach (var source in audioSources)
{
if (source.clip.name == triggerEvent.ParameterString)
{
source.Play();
}
}
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.DestroyObject)
{
Destroy(obj);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SendRPC)
{
object[] parameters = VRC_Serialization.ParameterDecoder(triggerEvent.ParameterBytes);
Type[] parameterTypes = new Type[parameters.Length];
for (int paramIndex = 0; paramIndex < parameters.Length; ++paramIndex)
{
parameterTypes[paramIndex] = parameters[paramIndex].GetType();
}
foreach (MonoBehaviour mono in obj.GetComponents <MonoBehaviour>())
{
MethodInfo methodInfo = mono.GetType().GetMethod(triggerEvent.ParameterString, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, Type.DefaultBinder, parameterTypes, null);
if (methodInfo != null)
{
methodInfo.Invoke(mono, parameters);
}
}
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetComponentActive)
{
Type type = instance_.GetTypeForComponent(triggerEvent.ParameterString);
if (type != null)
{
PropertyInfo property = type.GetProperty("enabled");
if (property != null)
{
foreach (Component component in obj.GetComponents(type))
{
bool value = (bool)property.GetValue(component, null);
bool newValue = VRC_EventHandler.BooleanOp(triggerEvent.ParameterBoolOp, value);
property.SetValue(component, newValue, null);
}
}
}
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetGameObjectActive)
{
bool newValue = VRC_EventHandler.BooleanOp(triggerEvent.ParameterBoolOp, obj.activeSelf);
obj.SetActive(newValue);
CyanEmuTriggerHelper triggerHelper = obj.GetComponent <CyanEmuTriggerHelper>();
if (triggerHelper != null && isTriggerGlobalBroadcast_)
{
if (newValue && triggerHelper.HasGlobalOnDisable)
{
instance_.LogWarning("Posisble OnEnable or OnTimer oversync!");
}
else if (!newValue && triggerHelper.HasGlobalOnDisable)
{
instance_.LogWarning("Posisble OnDisable oversync!");
}
}
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetLayer)
{
obj.layer = triggerEvent.ParameterInt;
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetMaterial)
{
Material mat = VRC_SceneDescriptor.GetMaterial(triggerEvent.ParameterString);
obj.GetComponent <Renderer>().material = mat;
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetParticlePlaying)
{
ParticleSystem system = obj.GetComponent <ParticleSystem>();
bool newValue = VRC_EventHandler.BooleanOp(triggerEvent.ParameterBoolOp, system.isPlaying);
if (newValue)
{
system.Play();
}
else
{
system.Stop();
}
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetUIText)
{
obj.GetComponent <UnityEngine.UI.Text>().text = triggerEvent.ParameterString;
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SpawnObject)
{
GameObject prefab = VRC_SceneDescriptor.GetPrefab(triggerEvent.ParameterString);
CyanEmuMain.SpawnObject(prefab, obj.transform.position, obj.transform.rotation);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.TeleportPlayer)
{
if (isBufferedExecution)
{
instance_.LogWarning("Teleport player actions should not be buffered. Ignoring");
}
else
{
if (CyanEmuPlayerController.instance != null)
{
CyanEmuPlayerController.instance.Teleport(triggerEvent.ParameterObjects[0].transform, triggerEvent.ParameterBoolOp == VRC_EventHandler.VrcBooleanOp.True);
}
else
{
instance_.LogWarning("No player container to teleport!");
}
if (eventInfo.broadcast != VRC_EventHandler.VrcBroadcastType.Local)
{
instance_.LogWarning("TeleportPlayer action should be set to local!");
}
}
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AddForce)
{
HandleTriggerPhysicsEvent(triggerEvent, obj);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AddVelocity)
{
HandleTriggerPhysicsEvent(triggerEvent, obj);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetVelocity)
{
HandleTriggerPhysicsEvent(triggerEvent, obj);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AddAngularVelocity)
{
HandleTriggerPhysicsEvent(triggerEvent, obj);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetAngularVelocity)
{
HandleTriggerPhysicsEvent(triggerEvent, obj);
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AddDamage)
{
HandleTriggerDamageEvent(triggerEvent, obj);
if (isBufferedExecution)
{
instance_.LogWarning("AddDamage action should not be buffered!");
}
else if (eventInfo.broadcast != VRC_EventHandler.VrcBroadcastType.Local)
{
instance_.LogWarning("AddDamage action should be set to local!");
}
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.AddHealth)
{
HandleTriggerDamageEvent(triggerEvent, obj);
if (isBufferedExecution)
{
instance_.LogWarning("AddHealth action should not be buffered!");
}
else if (eventInfo.broadcast != VRC_EventHandler.VrcBroadcastType.Local)
{
instance_.LogWarning("AddHealth action should be set to local!");
}
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetWebPanelURI)
{
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.SetWebPanelVolume)
{
}
else if (triggerEvent.EventType == VRC_EventHandler.VrcEventType.MeshVisibility)
{
}
}
// Token: 0x06005A54 RID: 23124 RVA: 0x001F72A8 File Offset: 0x001F56A8
private static bool isEventReady(VRC_EventLog.EventLogEntry e, bool logError)
{
if (!string.IsNullOrEmpty(e.ObjectPath) && e.Event.ParameterObject == null)
{
if (logError)
{
Debug.LogError("Could not find target " + e.ObjectPath + " for " + e.ToString());
}
return(false);
}
if (e.Event.ParameterObject != null && !VRC.Network.IsObjectReady(e.Event.ParameterObject))
{
if (logError)
{
Debug.LogError(string.Concat(new string[]
{
"Object did not ready in time ",
e.ObjectPath,
" for ",
e.ToString(),
" because ",
e.Event.ParameterObject.WhyNotReady()
}));
}
return(false);
}
if (e.Event.EventType == VRC_EventHandler.VrcEventType.SendRPC)
{
object[] array = null;
try
{
array = VRC_Serialization.ParameterDecoder(e.Event.ParameterBytes, true);
}
catch (KeyNotFoundException ex)
{
if (logError)
{
Debug.LogError(string.Concat(new string[]
{
"RPC Parameters did not ready in time ",
e.ObjectPath,
" for ",
e.ToString(),
" because ",
ex.Message
}));
}
return(false);
}
if (array == null || array.Length <= 0)
{
return(true);
}
if (array.Any((object p) => p == null || (p is GameObject && !(p as GameObject).IsReady())))
{
if (logError)
{
string[] value = (from p in array
where p == null || (p is GameObject && !(p as GameObject).IsReady())
select(p != null) ? ((p as GameObject).name + ": " + (p as GameObject).WhyNotReady()) : "parameter is null").ToArray <string>();
Debug.LogError(string.Concat(new string[]
{
"RPC Parameters did not ready in time ",
e.ObjectPath,
" for ",
e.ToString(),
" because ",
string.Join(", ", value)
}));
}
return(false);
}
return(true);
}
return(true);
}
