// 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);
}
public static void AddTransferEvent(GameObject srcState, KeyCode code, GameObject endState)
{
if (srcState == endState)
{
return;
}
// Using 'Always' because it was annoying when trying to break with multiple people.
VRC_Trigger.TriggerEvent triggerEvent = new VRC_Trigger.TriggerEvent();
triggerEvent.TriggerType = VRC_Trigger.TriggerType.OnKeyDown;
triggerEvent.BroadcastType = VRC_EventHandler.VrcBroadcastType.Local;
triggerEvent.Key = code;
// Turn on the next state
VRC_EventHandler.VrcEvent action = new VRC_EventHandler.VrcEvent();
action.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
action.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.True;
action.ParameterObjects = new GameObject[] { endState };
triggerEvent.Events.Add(action);
// Turn off this state
action = new VRC_EventHandler.VrcEvent();
action.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
action.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.False;
action.ParameterObjects = new GameObject[] { srcState };
triggerEvent.Events.Add(action);
// Add it to the source.
VRC_Trigger trigger = srcState.AddComponent <VRC_Trigger>();
trigger.Triggers.Add(triggerEvent);
}
private void CheckForPlayerLayerOverSync(VRC_Trigger.TriggerEvent triggerEvent)
{
if ((triggerEvent.Layers & PLAYER_LAYER) != 0 && triggerEvent.BroadcastType.IsEveryoneBroadcastType())
{
this.LogWarning("Player layer Enter/Exit trigger Oversync! " + triggerEvent.GetTriggerEventAsString());
}
}
// Token: 0x06005AB4 RID: 23220 RVA: 0x001F9958 File Offset: 0x001F7D58
protected override void OnNetworkReady()
{
base.OnNetworkReady();
if (!VRC_EventHandler.HasEventTrigger(base.gameObject))
{
VRC_Trigger orAddComponent = base.gameObject.GetOrAddComponent <VRC_Trigger>();
List <VRC_Trigger.TriggerEvent> triggers = orAddComponent.Triggers;
VRC_Trigger.TriggerEvent triggerEvent = new VRC_Trigger.TriggerEvent();
triggerEvent.BroadcastType = VRC_EventHandler.VrcBroadcastType.Local;
triggerEvent.TriggerType = VRC_Trigger.TriggerType.OnInteract;
triggerEvent.Events = (from evt in this.baseStation.ProvideEvents()
where evt.Name == "UseStation"
select evt).ToList <VRC_EventHandler.VrcEvent>();
triggers.Add(triggerEvent);
}
else
{
VRC_Trigger component = base.GetComponent <VRC_Trigger>();
if (component != null)
{
foreach (VRC_Trigger.TriggerEvent triggerEvent2 in from t in component.Triggers
where t.Events.Any((VRC_EventHandler.VrcEvent e) => e.ParameterString == "UseStation" || e.ParameterString == "ExitStation")
select t)
{
triggerEvent2.BroadcastType = VRC_EventHandler.VrcBroadcastType.Local;
}
}
VRC_UseEvents component2 = base.GetComponent <VRC_UseEvents>();
if (component2 != null)
{
component2.BroadcastType = VRC_EventHandler.VrcBroadcastType.Local;
component2.EventName = "UseStation";
}
}
Collider component3 = base.gameObject.GetComponent <Collider>();
if (component3 == null)
{
BoxCollider boxCollider = base.gameObject.AddComponent <BoxCollider>();
boxCollider.isTrigger = true;
}
VRC_EventHandler component4 = base.GetComponent <VRC_EventHandler>();
if (component4 != null)
{
VRC_Station component5 = base.GetComponent <VRC_Station>();
using (IEnumerator <VRC_EventHandler.VrcEvent> enumerator2 = component5.ProvideEvents().GetEnumerator())
{
while (enumerator2.MoveNext())
{
VRC_EventHandler.VrcEvent evt = enumerator2.Current;
VRC_StationInternal t = this;
if (!component4.Events.Any((VRC_EventHandler.VrcEvent item) => item.Name == evt.Name && item.ParameterObjects != null && item.ParameterObjects.Contains(t.gameObject)))
{
component4.Events.Add(evt);
}
}
}
}
}
private static IEnumerator ExecuteTriggerDelay(VRC_Trigger.TriggerEvent trigger)
{
bool isGlobalBroadcast = isTriggerGlobalBroadcast_;
yield return(new WaitForSeconds(trigger.AfterSeconds));
ExecuteTriggerNow(trigger, isGlobalBroadcast);
}
public static VRC_Trigger GetTriggerForEvent(VRC_Trigger.TriggerEvent trigEvent)
{
if (instance_ == null)
{
return(null);
}
return(instance_.triggerEventToTrigger_[trigEvent]);
}
public void ExecuteTrigger(VRC_Trigger.TriggerEvent trigger)
{
if (!gameObject.activeInHierarchy || !Trigger.enabled)
{
return;
}
CyanEmuTriggerExecutor.ExecuteTrigger(trigger);
}
/// <summary>
/// Trigger event generation
/// </summary>
/// <param name="RPCName"></param>
/// <param name="BroadCastType"></param>
/// <returns></returns>
public VRC_Trigger.TriggerEvent Triggerevent(string RPCName, VRC_EventHandler.VrcBroadcastType BroadCastType)
{
VRC_Trigger.TriggerEvent EventTrigger = new VRC_Trigger.TriggerEvent
{
TriggerType = VRC_Trigger.TriggerType.Custom,
BroadcastType = BroadCastType,
Name = RPCName,
TriggerIndividuals = true
};
EventTrigger.Events.Add(VrcEvent(RPCName));
return(EventTrigger);
}
/// <summary>
/// Collider Trigger Event
/// </summary>
/// <param name="trigger"></param>
/// <param name="state"></param>
/// <returns></returns>
public VRC_Trigger.TriggerEvent ColliderTriggerEvent(VRC_Trigger.TriggerType trigger, bool state)
{
VRC_Trigger.TriggerEvent EventTrigger = new VRC_Trigger.TriggerEvent
{
TriggerType = trigger,
BroadcastType = VRC_EventHandler.VrcBroadcastType.Local,
Name = "GameObject State",
TriggerIndividuals = true
};
EventTrigger.Events.Add(ColliderVrcEvent(state));
return(EventTrigger);
}
public static int GetTriggerEventIndex(this VRC_Trigger trigger, VRC_Trigger.TriggerEvent trigEvent)
{
for (int curEvent = 0; curEvent < trigger.Triggers.Count; ++curEvent)
{
if (trigEvent == trigger.Triggers[curEvent])
{
return(curEvent);
}
}
return(-1);
}
public void ExecuteTrigger(VRC_Trigger.TriggerEvent trigger)
{
if (
(!gameObject.activeInHierarchy || !Trigger.enabled) &&
trigger.TriggerType != VRC.SDKBase.VRC_Trigger.TriggerType.OnDisable
)
{
return;
}
CyanEmuTriggerExecutor.ExecuteTrigger(trigger);
}
public static void ExecuteEvent(VRC_EventHandler.EventInfo eventInfo, VRC_Trigger.TriggerEvent originalTrigger)
{
// Only save when we don't have an instigator.
// Todo, check for this properly.
if (eventInfo.broadcast.IsBufferedBroadcastType() && eventInfo.instagator != null)
{
instance_.Log("Adding event to the buffer queue");
instance_.bufferManager_.SaveBufferedEvent(eventInfo);
}
if (eventInfo.evt.ParameterObjects.Length > 0)
{
foreach (GameObject obj in eventInfo.evt.ParameterObjects)
{
if (obj == null)
{
instance_.LogError("Object is null! It was probably deleted and but a trigger is still trying to modify it!");
continue;
}
try
{
ExecuteEventForObject(eventInfo.evt, obj, eventInfo, originalTrigger);
}
catch (Exception e)
{
instance_.LogError(e.ToString());
}
if (eventInfo.evt.EventType == VRC_EventHandler.VrcEventType.SpawnObject && eventInfo.evt.ParameterObjects.Length > 1)
{
instance_.LogWarning("Only spawning one object since VRChat limits spawning.");
break;
}
}
}
else
{
instance_.LogWarning("No Object specified for trigger. This is unsupported");
instance_.LogError("Trigger with no receiver means you probably deleted the object but are still trying to perform actions on it.");
}
}
public static void ExecuteTrigger(VRC_Trigger.TriggerEvent trigger)
{
if (!instance_.networkReady_)
{
instance_.deferredTriggers_.Add(trigger);
instance_.Log("Deferring Trigger: " + trigger.GetTriggerEventAsString());
return;
}
if (trigger.AfterSeconds != 0)
{
instance_.Log("Delaying Execution of trigger name: " + trigger.GetTriggerEventAsString());
instance_.StartCoroutine(ExecuteTriggerDelay(trigger));
}
else
{
ExecuteTriggerNow(trigger, isTriggerGlobalBroadcast_);
}
}
public bool AddAvatarPedestalsToTrigger(GameObject MyObjectWithTrigger, List <GameObject> MyAvatarPedestals)
{
VRC_Trigger MyTriggerScript;
List <VRC_Trigger.TriggerEvent> TriggerEvents;
VRC_Trigger.TriggerEvent MyTriggerEvent;
List <VRC_EventHandler.VrcEvent> MyEvents;
VRC_EventHandler.VrcEvent MyEvent;
if (MyObjectWithTrigger == null)
{
CustomMessage = "Select Objects With Trigger If You Want To Toggle Avatar Pedestals By Pressing Button";
return(false);
}
MyTriggerScript = MyObjectWithTrigger.GetComponent <VRC_Trigger>();
if (MyTriggerScript == null)
{
CustomMessage = "Object Does Not Contain A Trigger";
return(false);
}
MyTriggerScript.interactText = "Avatars";
TriggerEvents = MyTriggerScript.Triggers;
MyTriggerEvent = new VRC_Trigger.TriggerEvent();
MyTriggerEvent.TriggerType = VRC_Trigger.TriggerType.OnInteract;
if (bLocalActivateByTrigger)
{
MyTriggerEvent.BroadcastType = VRC_EventHandler.VrcBroadcastType.Local;
}
MyEvents = MyTriggerEvent.Events;
MyEvent = new VRC_EventHandler.VrcEvent();
MyEvent.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
MyEvent.ParameterObjects = MyAvatarPedestals.ToArray();
MyEvent.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.Toggle;
MyEvents.Add(MyEvent);
TriggerEvents.Add(MyTriggerEvent);
return(true);
}
public static string GetTriggerEventAsString(this VRC_Trigger.TriggerEvent trigEvent)
{
string path = "null";
int eventIndex = -1;
VRC_Trigger trig = CyanEmuTriggerExecutor.GetTriggerForEvent(trigEvent);
if (trig != null)
{
eventIndex = trig.GetTriggerEventIndex(trigEvent);
path = CyanEmuUtils.PathForObject(trig.gameObject);
}
return(string.Format(
"Trigger Event[{0}] \"{1}\" type: {2}, broadcast: {3}, delay: {4}, path: {5}",
eventIndex,
trigEvent.Name,
trigEvent.TriggerType,
trigEvent.BroadcastType,
trigEvent.AfterSeconds,
path
));
}
GameObject initRemoteButton(string name, GameObject remote)
{
GameObject button = new GameObject(name);
button.transform.parent = remote.transform;
button.transform.localPosition = new Vector3(0, 0, 0);
button.transform.localRotation = new Quaternion(0, 0, 0, 0);
button.transform.localScale = new Vector3(1, 1, 1);
BoxCollider collider = button.AddComponent <BoxCollider> ();
collider.isTrigger = true;
collider.size = new Vector3(0.01f, 0.05f, 0.02f);
button.AddComponent <VRC_EventHandler> ();
VRC_Trigger trigger = button.AddComponent <VRC_Trigger> ();
VRC_Trigger.TriggerEvent onInteract = new VRC_Trigger.TriggerEvent();
onInteract.TriggerType = VRC_Trigger.TriggerType.OnInteract;
onInteract.BroadcastType = VRC_EventHandler.VrcBroadcastType.AlwaysBufferOne;
trigger.Triggers.Add(onInteract);
return(button);
}
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)
{
}
}
public static void ExecuteTriggerNow(VRC_Trigger.TriggerEvent trigger, bool prevGlobal)
{
if (executionDepth_ > MAX_EXECUTION_DEPTH_)
{
instance_.LogError("Reached maximum execution depth of " + MAX_EXECUTION_DEPTH_ + "! Failed to execute trigger!");
return;
}
++executionDepth_;
instance_.Log("Executing Trigger: " + trigger.GetTriggerEventAsString());
bool globalBroadcast = trigger.BroadcastType != VRC_EventHandler.VrcBroadcastType.Local;
bool setGlobal = false;
if ((!prevGlobal && globalBroadcast) || (prevGlobal && !isTriggerGlobalBroadcast_))
{
isTriggerGlobalBroadcast_ = true;
setGlobal = true;
}
if (prevGlobal && trigger.BroadcastType.IsEveryoneBroadcastType())
{
// Custom trigger oversync
instance_.LogWarning("Potential OverSync! " + trigger.GetTriggerEventAsString());
}
// Random - No error checking. Assumes sum of all values is >= 1.
if (trigger.Probabilities.Length != 0)
{
float value = UnityEngine.Random.value;
int ind = 0;
float sum = 0;
while (sum < value)
{
sum += trigger.Probabilities[ind++];
if (sum >= value)
{
VRC_EventHandler.VrcEvent triggerEvent = trigger.Events[ind - 1];
VRC_EventHandler.EventInfo eventInfo = new VRC_EventHandler.EventInfo()
{
broadcast = trigger.BroadcastType,
evt = triggerEvent,
instagator = instance_.gameObject // todo? set player?
};
ExecuteEvent(eventInfo, trigger);
break;
}
}
}
else
{
foreach (VRC_EventHandler.VrcEvent triggerEvent in trigger.Events)
{
VRC_EventHandler.EventInfo eventInfo = new VRC_EventHandler.EventInfo()
{
broadcast = trigger.BroadcastType,
evt = triggerEvent,
instagator = instance_.gameObject // todo? set player?
};
ExecuteEvent(eventInfo, trigger);
}
}
if (setGlobal)
{
isTriggerGlobalBroadcast_ = false;
}
--executionDepth_;
}
public void setNewCode(string newCode)
{
int[] codeArray;
try {
codeArray = newCode.Select(t => int.Parse(t.ToString())).ToArray();
} catch {
throw new Exception("invalid character in code.");
}
pinButtons = new GameObject[codeArray.Length];
firstButton = true;
GameObject nextButton = null;
GameObject tempButton = null;
for (int i = 0; i < buttons.Length; i++)
{
var dummy = createNewButton(i, false);
dummyButtons[i] = dummy;
}
for (int i = 0; i < codeArray.Length; i++)
{
if (i == 0)
{
dummyButtons[codeArray[i]].SetActive(false);
tempButton = createNewButton(codeArray[i], true);
nextButton = createNewButton(codeArray[i + 1], true);
}
else if (i + 1 < codeArray.Length)
{
tempButton = nextButton;
nextButton = createNewButton(codeArray[i + 1], true);
}
else
{
tempButton = nextButton;
nextButton = null;
}
var trigEvent = new VRC_Trigger.TriggerEvent {
BroadcastType = VRC_EventHandler.VrcBroadcastType.Local,
TriggerType = VRC_Trigger.TriggerType.OnInteract
};
var trigRef = tempButton.AddComponent <VRC_Trigger>();
trigRef.Triggers.Add(trigEvent);
var vrcEvent = new VRC_EventHandler.VrcEvent {
EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive,
ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.True,
ParameterObjects = new GameObject[1],
};
tempButton.SetActive(firstButton);
firstButton = false;
vrcEvent.ParameterObjects[0] = nextButton != null ? nextButton : mainMenu;
if (i + 1 < codeArray.Length && codeArray[i] != codeArray[i + 1])
{
Array.Resize(ref vrcEvent.ParameterObjects, 2);
vrcEvent.ParameterObjects[1] = dummyButtons[codeArray[i]];
}
var vrcEvent2 = new VRC_EventHandler.VrcEvent {
EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive,
ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.False,
ParameterObjects = new GameObject[1]
};
vrcEvent2.ParameterObjects[0] = nextButton != null ? tempButton : pinMenu;
if (i + 1 < codeArray.Length && codeArray[i] != codeArray[i + 1])
{
Array.Resize(ref vrcEvent2.ParameterObjects, 2);
vrcEvent2.ParameterObjects[1] = dummyButtons[codeArray[i + 1]];
}
trigEvent.Events.Add(vrcEvent);
trigEvent.Events.Add(vrcEvent2);
pinButtons[i] = tempButton;
}
var distinctCodeArray = codeArray.Distinct().ToArray();
foreach (var button in dummyButtons)
{
var trig = button.AddComponent <VRC_Trigger>();
var trigEvent = new VRC_Trigger.TriggerEvent {
BroadcastType = VRC_EventHandler.VrcBroadcastType.Local,
TriggerType = VRC_Trigger.TriggerType.OnInteract
};
trig.Triggers.Add(trigEvent);
var vrcEvent = new VRC_EventHandler.VrcEvent {
EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive,
ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.True,
ParameterObjects = new GameObject[distinctCodeArray.Length]
};
vrcEvent.ParameterObjects[0] = pinButtons[0];
for (int i = 1; i < vrcEvent.ParameterObjects.Length; i++)
{
vrcEvent.ParameterObjects[i] = dummyButtons[distinctCodeArray[i]];
}
var vrcEvent2 = new VRC_EventHandler.VrcEvent {
EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive,
ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.False,
ParameterObjects = new GameObject[codeArray.Length]
};
vrcEvent2.ParameterObjects[0] = dummyButtons[codeArray[0]];
for (int i = 1; i < vrcEvent2.ParameterObjects.Length; i++)
{
vrcEvent2.ParameterObjects[i] = pinButtons[i];
}
trigEvent.Events.Add(vrcEvent);
trigEvent.Events.Add(vrcEvent2);
ResetEvent = trigEvent;
}
pinButtons.Last().GetComponent <VRC_Trigger>().Triggers.Add(ResetEvent);
}
public void setupTriggers(List <TScreen> screens)
{
foreach (SOption o in options)
{
if (!o.optionObj)
{
throw new MissingReferenceException("Could not set up triggers; Game Objects for screen " + id + " have not been generated.");
}
VRC_EventHandler evh = o.optionObj.GetComponent <VRC_EventHandler>();
if (!evh)
{
o.optionObj.AddComponent <VRC_EventHandler>();
}
// Remove any pre-existing triggers
VRC_Trigger t = o.optionObj.GetComponent <VRC_Trigger>();
if (t)
{
Object.DestroyImmediate(t);
}
// Add an event handler and trigger
VRC_Trigger trigger = o.optionObj.AddComponent <VRC_Trigger> ();
trigger.interactText = "Select";
trigger.proximity = 1;
VRC_Trigger.TriggerEvent onInteract = new VRC_Trigger.TriggerEvent();
onInteract.TriggerType = VRC_Trigger.TriggerType.OnInteract;
onInteract.BroadcastType = VRC_EventHandler.VrcBroadcastType.AlwaysBufferOne;
VRC_EventHandler.VrcEvent enableDestination = new VRC_EventHandler.VrcEvent();
VRC_EventHandler.VrcEvent disableThisScreen = new VRC_EventHandler.VrcEvent();
enableDestination.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
disableThisScreen.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
enableDestination.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.True;
disableThisScreen.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.False;
enableDestination.ParameterObjects = new GameObject[1];
disableThisScreen.ParameterObjects = new GameObject[1];
enableDestination.ParameterObjects.SetValue(screens [o.destination].gameScreen, 0);
if (o.screen == null)
{
throw new MissingReferenceException("option has no screen");
}
if (o.screen.gameScreen == null)
{
throw new MissingReferenceException("Screen has no game screen");
}
if (disableThisScreen.ParameterObjects == null)
{
throw new MissingReferenceException("No paraemter objects found");
}
disableThisScreen.ParameterObjects.SetValue(o.screen.gameScreen, 0);
onInteract.Events.Add(enableDestination);
onInteract.Events.Add(disableThisScreen);
trigger.Triggers.Add(onInteract);
}
}
private void SetTrigger(VRC_Trigger trigger)
{
if (trigger == null)
{
this.LogError("Trigger is null. Destroying helper.");
DestroyImmediate(this);
return;
}
Trigger = trigger;
CyanEmuTriggerExecutor.AddTrigger(Trigger);
hasObjectSync = GetComponent <VRC_ObjectSync>();
VRC_CombatSystem combatSystem = FindObjectOfType <VRC_CombatSystem>();
// Go through and make sure all null targets reference itself.
for (int trig = 0; trig < Trigger.Triggers.Count; ++trig)
{
VRC_Trigger.TriggerEvent trigEvent = Trigger.Triggers[trig];
for (int trigEventInd = 0; trigEventInd < trigEvent.Events.Count; ++trigEventInd)
{
VRC_EventHandler.VrcEvent vrcEvent = trigEvent.Events[trigEventInd];
GameObject obj = gameObject;
bool isCombat = false;
if (
(vrcEvent.EventType == VRC_EventHandler.VrcEventType.AddDamage ||
vrcEvent.EventType == VRC_EventHandler.VrcEventType.AddHealth) &&
combatSystem != null
)
{
obj = combatSystem.gameObject;
isCombat = true;
}
if (vrcEvent.ParameterObjects == null || vrcEvent.ParameterObjects.Length == 0)
{
if (vrcEvent.ParameterObject != null)
{
obj = vrcEvent.ParameterObject;
}
vrcEvent.ParameterObjects = new GameObject[] { obj };
this.LogWarning("VRC_Trigger[" + trig + "][" + trigEventInd + "] has no objects. Setting it to target itself. " + VRC.Tools.GetGameObjectPath(obj));
}
else
{
bool found = false;
for (int i = 0; i < vrcEvent.ParameterObjects.Length; ++i)
{
if (vrcEvent.ParameterObjects[i] == null)
{
vrcEvent.ParameterObjects[i] = obj;
found = true;
}
}
if (found && !isCombat)
{
this.LogWarning("VRC_Trigger[" + trig + "][" + trigEventInd + "] has null targets. Setting targets to itself. " + VRC.Tools.GetGameObjectPath(obj));
}
}
}
}
for (int i = 0; i < Trigger.Triggers.Count; ++i)
{
if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnEnterTrigger)
{
enterTriggers.Add(Trigger.Triggers[i]);
CheckForPlayerLayerOverSync(Trigger.Triggers[i]);
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnExitTrigger)
{
exitTriggers.Add(Trigger.Triggers[i]);
CheckForPlayerLayerOverSync(Trigger.Triggers[i]);
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnEnterCollider)
{
enterCollider.Add(Trigger.Triggers[i]);
CheckForPlayerLayerOverSync(Trigger.Triggers[i]);
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnExitCollider)
{
exitCollider.Add(Trigger.Triggers[i]);
CheckForPlayerLayerOverSync(Trigger.Triggers[i]);
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnTimer)
{
Trigger.ResetClock(Trigger.Triggers[i]);
timerTriggers.Add(Trigger.Triggers[i]);
if (Trigger.Triggers[i].BroadcastType.IsAlwaysBufferedBroadcastType())
{
HasGlobalOnEnable = true;
}
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnInteract)
{
interactTriggers.Add(Trigger.Triggers[i]);
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnKeyDown || Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnKeyUp)
{
onKeyTriggers.Add(Trigger.Triggers[i]);
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnParticleCollision)
{
particleCollider.Add(Trigger.Triggers[i]);
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnPlayerJoined)
{
if (Trigger.Triggers[i].BroadcastType.IsAlwaysBufferedBroadcastType())
{
this.LogWarning("Oversync on player joined! " + Trigger.Triggers[i].GetTriggerEventAsString());
}
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnPlayerLeft)
{
if (Trigger.Triggers[i].BroadcastType.IsAlwaysBufferedBroadcastType())
{
this.LogWarning("Oversync on player left! " + Trigger.Triggers[i].GetTriggerEventAsString());
}
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnEnable)
{
if (Trigger.Triggers[i].BroadcastType.IsAlwaysBufferedBroadcastType())
{
HasGlobalOnEnable = true;
}
}
else if (Trigger.Triggers[i].TriggerType == VRC_Trigger.TriggerType.OnDisable)
{
if (Trigger.Triggers[i].BroadcastType.IsAlwaysBufferedBroadcastType())
{
HasGlobalOnDisable = true;
}
}
}
if (enterTriggers.Count + exitTriggers.Count + enterCollider.Count + exitCollider.Count + timerTriggers.Count + onKeyTriggers.Count + particleCollider.Count == 0)
{
enabled = false;
}
AddListeners();
}
private void CheckForMissingComponents()
{
Collider stationCollider = GetComponent <Collider>();
if (stationCollider == null)
{
gameObject.AddComponent <BoxCollider>().isTrigger = true;
}
#if UDON && UNITY_EDITOR
UdonBehaviour udon = GetComponent <UdonBehaviour>();
if (udon == null)
{
udon = gameObject.AddComponent <UdonBehaviour>();
udon.interactText = "Sit";
AbstractUdonProgramSource program = UnityEditor.AssetDatabase.LoadAssetAtPath <AbstractUdonProgramSource>("Assets/VRChat Examples/Prefabs/VRCChair/StationGraph.asset");
if (program != null)
{
udon.AssignProgramAndVariables(program.SerializedProgramAsset, new UdonVariableTable());
}
}
#endif
#if VRC_SDK_VRCSDK2
// Auto add a Interact Trigger to use the station
VRC_Trigger trigger = GetComponent <VRC_Trigger>();
if (trigger == null)
{
trigger = gameObject.AddComponent <VRCSDK2.VRC_Trigger>();
trigger.Triggers = new List <VRC_Trigger.TriggerEvent>();
trigger.interactText = "Sit";
VRC_Trigger.TriggerEvent onInteract = new VRC_Trigger.TriggerEvent
{
BroadcastType = VRC_EventHandler.VrcBroadcastType.Local,
TriggerType = VRC_Trigger.TriggerType.OnInteract,
Events = new List <VRC_EventHandler.VrcEvent>()
};
VRC_EventHandler.VrcEvent useStationEvent = new VRC_EventHandler.VrcEvent
{
EventType = VRC_EventHandler.VrcEventType.SendRPC,
ParameterString = "UseStation",
ParameterObjects = new[] { gameObject },
ParameterInt = 6,
};
onInteract.Events.Add(useStationEvent);
trigger.Triggers.Add(onInteract);
// Reinitialize the trigger now that it has the proper events added.
// Note that this only works as there were no vrc triggers on this object before.
CyanEmuTriggerHelper helper = GetComponent <CyanEmuTriggerHelper>();
if (helper != null)
{
DestroyImmediate(helper);
}
CyanEmuTriggerHelper.InitializeTrigger(trigger);
}
#endif
}
