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)
{
}
}
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();
}
public void OnStationExit(VRC.SDKBase.VRCStation station)
{
VRC_Trigger.TriggerCustom((station as VRCSDK2.VRC_Station).OnLocalPlayerExitStation);
Trigger.ExecuteTriggerType(VRC_Trigger.TriggerType.OnStationExited);
}
public void OnOwnershipTransferred(int ownerID)
{
VRC_Trigger.Trigger(gameObject, VRC.SDKBase.VRC_Trigger.TriggerType.OnOwnershipTransfer);
}
public bool GetProperties(GameObject GO)
{
int i;
List <Component> ListOfComponents = new List <Component>();
Transform MyTransform;
ParticleSystem MyParticleSystem;
ParticleSystemRenderer MyParticleSystemRenderer;
ParticleSystem.MainModule MyMainModule;
ParticleSystem.MinMaxCurve MyMinMaxCurve;
AnimationCurve MyAnimationCurve;
if (GO == null)
{
CustomMessage = "You've To Select Object";
return(false);
}
CustomMessage = "";
GUIList_Bool.Clear();
AddInfo(ref CustomMessage, "Tag: " + GO.tag, "|");
AddInfo(ref CustomMessage, "Layer: " + GO.layer, "; ");
GO.GetComponents(ListOfComponents);
AddInfo(ref CustomMessage, "Count Of Components: " + ListOfComponents.Count, "|");
for (i = 0; i < ListOfComponents.Count; i++)
{
AddInfo(ref CustomMessage, "Foldout_Start(" + i + ". ", "| |");
if (ListOfComponents[i] is Transform)
{
MyTransform = (Transform)ListOfComponents[i];
if (MyTransform != null)
{
AddInfo(ref CustomMessage, "Transform (" + ListOfComponents[i].ToString() + "))", "");
AddInfo(ref CustomMessage, "Position: X=" + MyTransform.localPosition.x + "; Y=" + MyTransform.localPosition.y + "; Z=" + MyTransform.localPosition.z, "|");
AddInfo(ref CustomMessage, "Global Position: X=" + MyTransform.position.x + "; Y=" + MyTransform.position.y + "; Z=" + MyTransform.position.z, "|");
AddInfo(ref CustomMessage, "Rotation: X=" + MyTransform.localRotation.x + "; Y=" + MyTransform.localRotation.y + "; Z=" + MyTransform.localRotation.z, "|");
AddInfo(ref CustomMessage, "Global Rotation: X=" + MyTransform.rotation.x + "; Y=" + MyTransform.rotation.y + "; Z=" + MyTransform.rotation.z, "|");
AddInfo(ref CustomMessage, "Scale: X=" + MyTransform.localScale.x + "; Y=" + MyTransform.localScale.y + "; Z=" + MyTransform.localScale.z, "|");
AddInfo(ref CustomMessage, "Global Scale: X=" + MyTransform.lossyScale.x + "; Y=" + MyTransform.lossyScale.y + "; Z=" + MyTransform.lossyScale.z, "|");
}
}
else if (ListOfComponents[i] is ParticleSystem)
{
MyParticleSystem = (ParticleSystem)ListOfComponents[i];
if (MyParticleSystem != null)
{
AddInfo(ref CustomMessage, "ParticleSystem (" + ListOfComponents[i].ToString() + "))", "");
MyMainModule = MyParticleSystem.main;
AddInfo(ref CustomMessage, "Foldout_Start(Main)", "|");
AddInfo(ref CustomMessage, "Duration: " + MyMainModule.duration, "|");
AddInfo(ref CustomMessage, "Looping: " + MyMainModule.loop, "|");
AddInfo(ref CustomMessage, "Prewarm: " + MyMainModule.prewarm, "|");
MyMinMaxCurve = MyParticleSystem.startDelay;
AddInfo(ref CustomMessage, "Foldout_Start(MinMaxCurve)", "|");
AddInfo(ref CustomMessage, "Mode: " + MyMinMaxCurve.mode, "|");
if (MyMinMaxCurve.mode == ParticleSystemCurveMode.Constant)
{
AddInfo(ref CustomMessage, "Value: " + MyMinMaxCurve.constant, "|");
}
else if (MyMinMaxCurve.mode == ParticleSystemCurveMode.Curve)
{
MyAnimationCurve = MyMinMaxCurve.curve;
if (MyAnimationCurve != null)
{
AddInfo(ref CustomMessage, "Length: " + MyAnimationCurve.length, "|");
AddInfo(ref CustomMessage, "Foldout_Start(Curve)", "|");
for (i = 0; i < MyAnimationCurve.length; i++)
{
AddInfo(ref CustomMessage, "Key[" + i + "]: Time: " + MyAnimationCurve.keys[i].time, "|");
AddInfo(ref CustomMessage, "Value: " + MyAnimationCurve.keys[i].value, ";");
}
AddInfo(ref CustomMessage, "Foldout_End", "|");
}
}
else if (MyMinMaxCurve.mode == ParticleSystemCurveMode.TwoCurves)
{
}
else if (MyMinMaxCurve.mode == ParticleSystemCurveMode.TwoConstants)
{
}
AddInfo(ref CustomMessage, "Foldout_End", "|");
AddInfo(ref CustomMessage, "Foldout_End", "|");
}
}
else if (ListOfComponents[i] is ParticleSystemRenderer)
{
MyParticleSystemRenderer = (ParticleSystemRenderer)ListOfComponents[i];
if (MyParticleSystemRenderer != null)
{
AddInfo(ref CustomMessage, "ParticleSystemRenderer (" + ListOfComponents[i].ToString() + "))", "");
AddInfo(ref CustomMessage, "Render Mode: " + MyParticleSystemRenderer.renderMode, "|");
AddInfo(ref CustomMessage, "Material: " + MyParticleSystemRenderer.sharedMaterial, "|");
AddInfo(ref CustomMessage, "Sort Mode: " + MyParticleSystemRenderer.sortMode, "|");
AddInfo(ref CustomMessage, "Sorting Fudge: " + MyParticleSystemRenderer.sortingFudge, "|");
AddInfo(ref CustomMessage, "Alignment: " + MyParticleSystemRenderer.alignment, "|");
AddInfo(ref CustomMessage, "Pivot: X=" + MyParticleSystemRenderer.pivot.x + "; Y=" + MyParticleSystemRenderer.pivot.y + "; Z=" + MyParticleSystemRenderer.pivot.z, "|");
AddInfo(ref CustomMessage, "Shadow Casting Mode: " + MyParticleSystemRenderer.shadowCastingMode, "|");
AddInfo(ref CustomMessage, "Receive Shadows: " + MyParticleSystemRenderer.receiveShadows, "|");
AddInfo(ref CustomMessage, "Sorting Layer ID: " + MyParticleSystemRenderer.sortingLayerID, "|");
AddInfo(ref CustomMessage, "Sorting Layer Name: " + MyParticleSystemRenderer.sortingLayerName, "|");
AddInfo(ref CustomMessage, "Sorting Order: " + MyParticleSystemRenderer.sortingOrder, "|");
AddInfo(ref CustomMessage, "Use Light Probes: " + MyParticleSystemRenderer.useLightProbes, "|");
AddInfo(ref CustomMessage, "Reflection Probe Usage: " + MyParticleSystemRenderer.reflectionProbeUsage, "|");
}
}
else if (ListOfComponents[i] is VRC_Trigger)
{
VRC_Trigger MyVRC_Trigger = (VRC_Trigger)ListOfComponents[i];
if (MyVRC_Trigger != null)
{
AddInfo(ref CustomMessage, "VRC_Trigger (" + ListOfComponents[i].ToString() + "))", "");
foreach (VRC.SDKBase.VRC_Trigger.TriggerEvent TE in MyVRC_Trigger.Triggers)
{
AddInfo(ref CustomMessage, "Foldout_Start(TriggerType: " + Eval(TE.TriggerType == VRC_Trigger.TriggerType.Custom, TE.TriggerType + " (" + TE.Name + ")", TE.TriggerType.ToString()) + "; BroadcastType: " + TE.BroadcastType + ")", "|");
AddInfo(ref CustomMessage, "AfterSeconds: " + TE.AfterSeconds, "|");
foreach (VRC.SDKBase.VRC_EventHandler.VrcEvent VRCE in TE.Events)
{
AddInfo(ref CustomMessage, "Foldout_Start(EventType: " + VRCE.EventType + ")", "|");
for (int l = 0; l < VRCE.ParameterObjects.Length; l++)
{
GameObject GO2 = VRCE.ParameterObjects[l];
if (!GO2)
{
continue;
}
AddInfo(ref CustomMessage, "ParameterObjects[" + l + "]: " + GO, "|");
}
AddInfo(ref CustomMessage, "ParameterBoolOp: " + VRCE.ParameterBoolOp, "|");
AddInfo(ref CustomMessage, "ParameterString: " + VRCE.ParameterString, "|");
AddInfo(ref CustomMessage, "ParameterBool: " + VRCE.ParameterBool, "|");
AddInfo(ref CustomMessage, "ParameterFloat: " + VRCE.ParameterFloat, "|");
AddInfo(ref CustomMessage, "ParameterInt: " + VRCE.ParameterInt, "|");
AddInfo(ref CustomMessage, "ParameterObject: " + VRCE.ParameterObject, "|");
AddInfo(ref CustomMessage, "Foldout_End", "|");
}
AddInfo(ref CustomMessage, "Foldout_End", "|");
}
}
}
else
{
AddInfo(ref CustomMessage, "Error (" + ListOfComponents[i].ToString() + "))", "");
}
AddInfo(ref CustomMessage, "Foldout_End", "|");
}
return(true);
}
public void OnOwnershipTransferred(int ownerID)
{
#if VRC_SDK_VRCSDK2
VRC_Trigger.Trigger(gameObject, VRC.SDKBase.VRC_Trigger.TriggerType.OnOwnershipTransfer);
#endif
}
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
}
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);
}
}
// Token: 0x06005436 RID: 21558 RVA: 0x001D15AD File Offset: 0x001CF9AD
private void OnControllerColliderHit(ControllerColliderHit hit)
{
VRC_Trigger.Trigger(hit.collider.gameObject, VRC_Trigger.TriggerType.OnAvatarHit);
}
void setupBackTrigger(VRC_Trigger backTrigger, int n, GameObject screen, GameObject remote)
{
if (backTrigger == null)
{
return;
}
backTrigger.interactText = "Back";
int i;
VRC_EventHandler.VrcEvent backEventTrue = new VRC_EventHandler.VrcEvent();
VRC_EventHandler.VrcEvent backEventFalse = new VRC_EventHandler.VrcEvent();
backEventTrue.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
backEventFalse.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
backEventTrue.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.True;
backEventFalse.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.False;
Transform prevImage = screen.transform.Find("image" + (n - 1));
if (prevImage == null)
{
DestroyImmediate(backTrigger);
return;
}
Transform currentImg = screen.transform.Find("image" + n);
if (currentImg == null)
{
DestroyImmediate(backTrigger);
return;
}
// Setting game objects true
int trueParamCount = 3;
Transform nextPrev = remote.transform.Find("backTo" + (n - 2));
Transform prev2Img = screen.transform.Find("image" + (n - 2));
if (prev2Img == null || nextPrev == null)
{
trueParamCount--;
}
Transform prevForward = remote.transform.Find("forwardTo" + (n));
if (prevForward == null)
{
trueParamCount--;
}
i = 0;
backEventTrue.ParameterObjects = new GameObject[trueParamCount];
backEventTrue.ParameterObjects.SetValue(prevImage.gameObject, i++);
if (prev2Img != null && nextPrev != null)
{
backEventTrue.ParameterObjects.SetValue(nextPrev.gameObject, i++);
}
if (prevForward != null)
{
backEventTrue.ParameterObjects.SetValue(prevForward.gameObject, i++);
}
// Setting game objects false
int falseParamCount = 3;
Transform currentForward = remote.transform.Find("forwardTo" + (n + 1));
if (currentForward == null)
{
falseParamCount--;
}
i = 0;
backEventFalse.ParameterObjects = new GameObject[falseParamCount];
backEventFalse.ParameterObjects.SetValue(currentImg.gameObject, i++);
backEventFalse.ParameterObjects.SetValue(backTrigger.gameObject, i++);
if (currentForward != null)
{
backEventFalse.ParameterObjects.SetValue(currentForward.gameObject, i++);
}
// Add both types of actions to trigger
backTrigger.Triggers[0].Events.Add(backEventTrue);
backTrigger.Triggers [0].Events.Add(backEventFalse);
}
void OnGUI()
{
GUILayout.Label("Drag Slideshow From Scene", EditorStyles.boldLabel);
slideshow = (GameObject)EditorGUILayout.ObjectField("Slideshow Asset", slideshow, typeof(GameObject), true);
GUILayout.Label("Click to select folder of images to add to the slideshow:", EditorStyles.label);
if (GUILayout.Button("Select directory with images"))
{
if (slideshow == null)
{
Debug.Log("Please select slideshow asset first.");
return;
}
string path = EditorUtility.OpenFolderPanel("Load png Textures", "", "");
// Set up relative path of texture image
string[] pathArray = path.Split('/'); // OpenFolderPanel always uses "/" instead of OS directory separator.
string[] relativePathArray = new string[0];
int j = 0;
bool pathing = false;
for (int i = 0; i < pathArray.Length; i++)
{
if (pathArray [i] == "Assets")
{
pathing = true;
relativePathArray = new string[pathArray.Length - i];
}
if (pathing)
{
relativePathArray [j] = pathArray [i];
j++;
}
}
string imagesDirPath = string.Join(SLASH_STRING, relativePathArray);
string[] files = Directory.GetFiles(path);
// Create Materials folder
materialsPath = imagesDirPath + SLASH_STRING + "Materials";
if (!AssetDatabase.IsValidFolder(materialsPath))
{
Debug.Log("No Materials folder found");
try {
AssetDatabase.CreateFolder(imagesDirPath, "Materials");
} catch (IOException e) {
Debug.Log("Exception while creating Materials Directory!");
Debug.Log(e.Message);
return;
}
}
GameObject screen = slideshow.transform.Find("screen").gameObject;
GameObject remote = slideshow.transform.Find("remote_control").gameObject;
GameObject sharedQuad = GameObject.CreatePrimitive(PrimitiveType.Quad);
int n = 1;
int imageCount = 0;
Array.Sort(files, new AlphanumComparatorFast());
foreach (string file in files)
{
if (endsWithImageExt(file))
{
imageCount++;
// Create new material
string[] filepathArray = file.Split(SLASH);
string filename = filepathArray [filepathArray.Length - 1];
Material newMaterial = new Material(Shader.Find("Standard"));
// Set new material's color and texture
newMaterial.color = new Color(0, 0, 0);
newMaterial.EnableKeyword("_EMISSION");
newMaterial.globalIlluminationFlags = MaterialGlobalIlluminationFlags.BakedEmissive;
Texture tex = (Texture)AssetDatabase.LoadAssetAtPath(imagesDirPath + SLASH_STRING + filename, typeof(Texture));
newMaterial.SetTexture("_EmissionMap", tex);
newMaterial.SetColor("_EmissionColor", Color.white);
// Save new material to file
AssetDatabase.CreateAsset(newMaterial, materialsPath + SLASH_STRING + filename + ".mat");
// Create image panel for each file
GameObject imgObj = initScreenImage("image" + n, screen, sharedQuad, newMaterial);
if (n != 1)
{
imgObj.SetActive(false);
}
// Create remote triggers for each file
GameObject forwardButton = initRemoteButton("forwardTo" + (n + 1), remote);
if (n != 1)
{
forwardButton.SetActive(false);
}
GameObject backButton = initRemoteButton("backTo" + (n - 1), remote);
backButton.SetActive(false);
backButton.GetComponent <BoxCollider>().center = new Vector3(-0.0325f, -0.0247f, -0.002f);
forwardButton.GetComponent <BoxCollider>().center = new Vector3(0.0325f, -0.0247f, -0.002f);
n++;
}
}
n = 1;
for (int i = 0; i < imageCount; i++)
{
// Set up triggers now that all game objects are created;
GameObject backButton = remote.transform.Find("backTo" + (n - 1)).gameObject;
GameObject forwardButton = remote.transform.Find("forwardTo" + (n + 1)).gameObject;
VRC_Trigger backTrigger = backButton.GetComponent <VRC_Trigger> ();
VRC_Trigger forwardTrigger = forwardButton.GetComponent <VRC_Trigger> ();
setupForwardTrigger(forwardTrigger, n, screen, remote);
setupBackTrigger(backTrigger, n, screen, remote);
n++;
}
Debug.Log("Set up " + imageCount + " images in the slideshow.");
DestroyImmediate(sharedQuad);
}
}
void setupForwardTrigger(VRC_Trigger forwardTrigger, int n, GameObject screen, GameObject remote)
{
forwardTrigger.interactText = "Forward";
VRC_EventHandler.VrcEvent forwardEventTrue = new VRC_EventHandler.VrcEvent();
VRC_EventHandler.VrcEvent forwardEventFalse = new VRC_EventHandler.VrcEvent();
forwardEventTrue.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
forwardEventFalse.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
forwardEventTrue.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.True;
forwardEventFalse.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.False;
int i;
Transform nextImage = screen.transform.Find("image" + (n + 1));
if (nextImage == null)
{
DestroyImmediate(forwardTrigger);
return;
}
Transform currentImg = screen.transform.Find("image" + (n));
if (currentImg == null)
{
DestroyImmediate(forwardTrigger);
return;
}
// Setting Game Objects True
int trueParamCount = 3;
Transform nextForward = remote.transform.Find("forwardTo" + (n + 2));
Transform next2Img = screen.transform.Find("image" + (n + 2));
if (next2Img == null || nextForward == null)
{
trueParamCount--;
}
Transform nextBack = remote.transform.Find("backTo" + n);
if (nextBack == null)
{
trueParamCount--;
}
i = 0;
forwardEventTrue.ParameterObjects = new GameObject [trueParamCount];
forwardEventTrue.ParameterObjects.SetValue(nextImage.gameObject, i++);
if (nextForward != null && next2Img != null)
{
forwardEventTrue.ParameterObjects.SetValue(nextForward.gameObject, i++);
}
if (nextBack != null)
{
forwardEventTrue.ParameterObjects.SetValue(nextBack.gameObject, i++);
}
// Setting Game Objects False
int falseParamCount = 3;
Transform currentBack = remote.transform.Find("backTo" + (n - 1));
if (currentBack == null)
{
falseParamCount--;
}
i = 0;
forwardEventFalse.ParameterObjects = new GameObject[falseParamCount];
forwardEventFalse.ParameterObjects.SetValue(currentImg.gameObject, i++);
forwardEventFalse.ParameterObjects.SetValue(forwardTrigger.gameObject, i++);
if (currentBack != null)
{
forwardEventFalse.ParameterObjects.SetValue(currentBack.gameObject, i++);
}
// Add both type of actions to Trigger
forwardTrigger.Triggers [0].Events.Add(forwardEventTrue);
forwardTrigger.Triggers [0].Events.Add(forwardEventFalse);
}