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_;
}
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 virtual void SetEvent(VRC_EventHandler.VrcEvent EventContents)
{
this.EventContents = EventContents;
}
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();
}
// Token: 0x06005A56 RID: 23126 RVA: 0x001F75F8 File Offset: 0x001F59F8
private void FixBooleanValues(VRC_EventHandler.VrcEvent evt, VRC_EventHandler handler)
{
if (evt == null || handler == null)
{
return;
}
if (evt.ParameterObject != null)
{
VRC_EventHandler.VrcEventType eventType = evt.EventType;
switch (eventType)
{
case VRC_EventHandler.VrcEventType.SetParticlePlaying:
{
Transform transform = evt.ParameterObject.transform;
if (transform != null)
{
ParticleSystem component = transform.GetComponent <ParticleSystem>();
if (component != null)
{
bool flag = VRC_EventHandler.BooleanOp(evt.ParameterBoolOp, component.isPlaying);
evt.ParameterBoolOp = ((!flag) ? VRC_EventHandler.VrcBooleanOp.False : VRC_EventHandler.VrcBooleanOp.True);
}
}
break;
}
case VRC_EventHandler.VrcEventType.TeleportPlayer:
{
Transform transform2 = evt.ParameterObject.transform;
if (transform2 != null)
{
bool flag2 = VRC_EventHandler.BooleanOp(evt.ParameterBoolOp, false);
evt.ParameterBoolOp = ((!flag2) ? VRC_EventHandler.VrcBooleanOp.False : VRC_EventHandler.VrcBooleanOp.True);
}
break;
}
default:
switch (eventType)
{
case VRC_EventHandler.VrcEventType.MeshVisibility:
{
Transform transform3 = evt.ParameterObject.transform;
if (transform3 != null)
{
MeshRenderer component2 = transform3.GetComponent <MeshRenderer>();
if (component2 != null)
{
bool flag3 = VRC_EventHandler.BooleanOp(evt.ParameterBoolOp, component2.enabled);
evt.ParameterBoolOp = ((!flag3) ? VRC_EventHandler.VrcBooleanOp.False : VRC_EventHandler.VrcBooleanOp.True);
}
}
break;
}
case VRC_EventHandler.VrcEventType.AnimationBool:
{
Animator animator = (!(evt.ParameterObject != null)) ? null : evt.ParameterObject.GetComponent <Animator>();
if (animator == null && handler != null)
{
animator = handler.gameObject.GetComponent <Animator>();
}
if (animator != null)
{
bool flag4 = VRC_EventHandler.BooleanOp(evt.ParameterBoolOp, animator.GetBool(evt.ParameterString));
evt.ParameterBoolOp = ((!flag4) ? VRC_EventHandler.VrcBooleanOp.False : VRC_EventHandler.VrcBooleanOp.True);
}
break;
}
}
break;
case VRC_EventHandler.VrcEventType.SetGameObjectActive:
{
Transform transform4 = evt.ParameterObject.transform;
if (transform4 != null)
{
bool flag5 = VRC_EventHandler.BooleanOp(evt.ParameterBoolOp, transform4.gameObject.activeSelf);
evt.ParameterBoolOp = ((!flag5) ? VRC_EventHandler.VrcBooleanOp.False : VRC_EventHandler.VrcBooleanOp.True);
}
break;
}
}
}
}
/** * <summary> * An abstract method that returns the specific VRC_CT_CustomEvent for the spawn class. For instance * a VRC_CT_ScoreboardEventSpawn returns a VRC_CT_ScoreboardEvent. Note: overriding classes need to give * the VRC_CT_CustomEvent the passed in VrcEvent through SetEvent(); * </summary> **/ public abstract VRC_CT_CustomEvent Create(VRC_EventHandler.VrcEvent e);
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 static void TriggerWorldObjectEvent(VRC_EventHandler.VrcEvent ev, VRC_EventHandler handler)
{
handler.TriggerEvent(ev, VRC_EventHandler.VrcBroadcastType.Always, handler.gameObject);
}
public override void SetEvent(VRC_EventHandler.VrcEvent EventContents)
{
base.SetEvent(EventContents);
string[] stringSplit = EventContents.ParameterString.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
VRC_CT_EventHandler.print("StringSplit.Length = " + stringSplit.Length);
if (EventContents.ParameterObject != null)
{
scoreboard = EventContents.ParameterObject.GetComponent <VRC_CT_ScoreboardManager>();
handler = EventContents.ParameterObject.GetComponent <VRC_EventHandler>();
}
if (stringSplit.Length < 5 || (stringSplit.Length == 4 && !(stringSplit[3].Equals(":") || stringSplit[3].Equals("?"))))
{
return;
}
Value1 = stringSplit[0];
try
{
intValue1 = int.Parse(Value1);
Value1 = "";
}
catch (Exception e) { }
if (Value1 != "" && Value1.StartsWith("\"") && Value1.EndsWith("\""))
{
Value1 = Value1.Substring(1, Value1.Length - 2);
}
Value2 = stringSplit[2];
try
{
intValue2 = int.Parse(Value2);
Value2 = "";
}
catch (Exception e) { }
if (Value2 != "" && Value2.StartsWith("\"") && Value2.EndsWith("\""))
{
Value2 = Value2.Substring(1, Value2.Length - 2);
}
if (Value1 == Value2)
{
return;
}
VRC_CT_EventHandler.print("Values have been found: " + (Value1 == "" ? intValue1.ToString() : Value1) + " and " + (Value2 == "" ? intValue2.ToString() : Value2));
try
{
compareBehavior = int.Parse(stringSplit[1]);
if (compareBehavior < 0)
{
compareBehavior = 0;
}
else if (compareBehavior > 7)
{
compareBehavior = 7;
}
}
catch (Exception e)
{
if (stringSplit[1].Contains("<"))
{
compareBehavior |= LESS_THAN;
}
if (stringSplit[1].Contains(">"))
{
compareBehavior |= GREATER_THAN;
}
if (stringSplit[1].Contains("="))
{
compareBehavior |= EQUALS;
}
if (stringSplit[1].Contains("!"))
{
int newBehavior = 0;
if ((compareBehavior & LESS_THAN) == 0)
{
newBehavior |= LESS_THAN;
}
if ((compareBehavior & GREATER_THAN) == 0)
{
newBehavior |= GREATER_THAN;
}
if ((compareBehavior & EQUALS) == 0)
{
newBehavior |= EQUALS;
}
compareBehavior = newBehavior;
}
}
// Operator Compiled: 0 - Always False, 1 - Less Than, 2 - Greater Than, 3 - Not,
// 4 - Equals, 5 - Less Than or Equal To, 6 - Greater Than or Equal To, 7 - Always True
if (stringSplit[3].Equals("?"))
{
// '?' and True Case
compareTrueEvent = stringSplit[4];
if (stringSplit.Length > 5)
{
if (stringSplit[5].Equals(":") && stringSplit.Length > 6)
{
// ':' and False Case
compareFalseEvent = stringSplit[6];
}
else
{
// False Case
compareFalseEvent = stringSplit[5];
}
}
}
else if (stringSplit[3].Equals(":"))
{
// ':' and False Case
compareFalseEvent = stringSplit[4];
}
else
{
// True Case
compareTrueEvent = stringSplit[3];
if (stringSplit.Length > 4)
{
if (stringSplit[4].Equals(":") && stringSplit.Length > 5)
{
// ':' False Case
compareFalseEvent = stringSplit[5];
}
else
{
// False Case
compareFalseEvent = stringSplit[4];
}
}
}
didLoad = true;
}
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);
}
}
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);
}
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 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);
}
