// Token: 0x06005A50 RID: 23120 RVA: 0x001F7154 File Offset: 0x001F5554
public void LogEvent(VRC_EventHandler eventHandler, VRC_EventHandler.VrcEvent vrcEvent, long combinedNetworkId, VRC_EventHandler.VrcBroadcastType broadcast, int instagatorId, float fastForward)
{
if (instagatorId <= 0)
{
instagatorId = VRC.Network.LocalInstigatorID;
}
if (vrcEvent.EventType == VRC_EventHandler.VrcEventType.SpawnObject || broadcast == VRC_EventHandler.VrcBroadcastType.Local)
{
this.Dispatcher.Execute(vrcEvent, broadcast, instagatorId, fastForward);
return;
}
VRC_EventLog.EventLogEntry eventLogEntry = new VRC_EventLog.EventLogEntry
{
Time = PhotonNetwork.time,
InstagatorPhotonId = instagatorId,
CombinedNetworkId = combinedNetworkId,
FastForward = fastForward,
Event = vrcEvent,
OriginalBroadcast = broadcast
}.DeepClone();
if (vrcEvent.ParameterObject != null)
{
eventLogEntry.ObjectPath = VRC.Network.GetGameObjectPath(vrcEvent.ParameterObject);
eventLogEntry.Event.ParameterObject = vrcEvent.ParameterObject;
}
this.FixBooleanValues(eventLogEntry.Event, this.Dispatcher.GetEventHandler(combinedNetworkId));
VRC_EventLog.AssignObjectParameter(eventLogEntry, this.Dispatcher);
Debug.Log("Replicating " + eventLogEntry.ToString());
this.Replicator.ProcessEvent(eventLogEntry, PhotonNetwork.player);
}
// 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);
}
}
}
}
}
// Token: 0x060058D9 RID: 22745 RVA: 0x001EC620 File Offset: 0x001EAA20
private void Start()
{
VRC_EventHandler componentInParent = base.GetComponentInParent <VRC_EventHandler>();
if (componentInParent != null)
{
for (int i = 0; i < componentInParent.Events.Count; i++)
{
if (componentInParent.Events[i].Name == "Use" && componentInParent.Events[i].ParameterObject == null)
{
componentInParent.Events[i].ParameterObject = base.gameObject;
}
}
}
this.calibrator = base.GetComponentInParent <VRC_AvatarCalibrator>();
this.switcher = base.GetComponent <VRCAvatarManager>();
VRCAvatarManager vrcavatarManager = this.switcher;
vrcavatarManager.OnAvatarCreated = (VRCAvatarManager.AvatarCreationCallback)Delegate.Combine(vrcavatarManager.OnAvatarCreated, new VRCAvatarManager.AvatarCreationCallback(this.AvatarCreated));
this.vrikCalib = base.GetComponent <VRCVrIkCalibrator>();
if (!string.IsNullOrEmpty(this.calibrator.blueprintId))
{
ApiAvatar.Fetch(this.calibrator.blueprintId, delegate(ApiAvatar bp)
{
this.avatar = bp;
this.switcher.SwitchAvatar(this.avatar, this.calibrator.scale, null);
Tools.SetLayerRecursively(base.gameObject, base.transform.parent.gameObject.layer, -1);
}, delegate(string message)
{
this.switcher.SwitchToErrorAvatar(1f);
});
}
}
void Start()
{
FindCustomEvents();
CustomEventNames = new List <string>();
CompiledEvents = new List <VRC_CT_CustomEvent>();
Handler = gameObject.GetComponent <VRC_EventHandler>();
Compile();
}
private static bool TriggerEvent(VRC_EventHandler __0, VRC_EventHandler.VrcEvent __1, VRC_EventHandler.VrcBroadcastType __2, int __3, float __4)
{
if (!string.IsNullOrEmpty(__1.ParameterString) && __1.ParameterString.Equals("SetAvatarUse") && (__2 != VRC_EventHandler.VrcBroadcastType.Local))
{
return(false);
}
return(true);
}
void Start()
{
Handler = gameObject.GetComponent <VRC_EventHandler>();
if (EventTypesToUpdate.Count > 0)
{
ChurroHandler = gameObject.GetComponent <VRC_CT_EventHandler>();
}
}
void Start()
{
handler = gameObject.GetComponent <VRC_EventHandler>();
if (delay == 0)
{
shouldUpdate = false;
handler.TriggerEvent(EventToLoad, VRC_EventHandler.VrcBroadcastType.Always);
}
}
public override void TriggerEvent()
{
if (EventContents.ParameterBool)
{
handler = EventContents.ParameterObject.GetComponent <VRC_EventHandler>();
}
handler.TriggerEvent(EventContents.ParameterString, EventContents.ParameterFloat == 0 ? VRC_EventHandler.VrcBroadcastType.Always
: EventContents.ParameterFloat > 1 ? VRC_EventHandler.VrcBroadcastType.Master : VRC_EventHandler.VrcBroadcastType.Local);
}
public override void SetEvent(VRC_EventHandler.VrcEvent EventContents)
{
EventContents.ParameterBool = VRC_EventHandler.BooleanOp(EventContents.ParameterBoolOp, true);
base.SetEvent(EventContents);
if (!EventContents.ParameterBool)
{
handler = EventContents.ParameterObject.GetComponent <VRC_EventHandler>();
}
}
// Token: 0x06005A95 RID: 23189 RVA: 0x001F8FF0 File Offset: 0x001F73F0
private void TriggerEvent(string name, VRC_EventHandler.VrcBroadcastType bc)
{
VRC_EventHandler componentInParent = base.GetComponentInParent <VRC_EventHandler>();
foreach (VRC_EventHandler.VrcEvent e2 in from e in componentInParent.Events
where e.Name == name
select e)
{
componentInParent.TriggerEvent(e2, bc, null, 0f);
}
}
void Start()
{
Handler = gameObject.GetComponent <VRC_EventHandler>();
Storage = gameObject.GetComponent <VRC_DataStorage>();
Values = new List <VRC_CT_ScoreboardValue>(gameObject.GetComponents <VRC_CT_ScoreboardValue>());
ScoreboardTexts = new List <VRC_CT_Scoreboard>();
foreach (GameObject g in Scoreboards)
{
ScoreboardTexts.AddRange(g.GetComponents <VRC_CT_Scoreboard>());
}
}
public override void SetEventHandlerGameObject(UnityEngine.GameObject obj)
{
if (handler == null || !UseScoreboardHandler)
{
handler = obj.GetComponent <VRC_EventHandler>();
}
if (scoreboard == null)
{
scoreboard = obj.GetComponent <VRC_CT_ScoreboardManager>();
}
didLoad = handler != null && scoreboard != null && didLoad;
}
// Token: 0x0600550B RID: 21771 RVA: 0x001D51D0 File Offset: 0x001D35D0
public void UseExit()
{
VRC_EventHandler vrc_EventHandler = base.GetComponent <VRC_EventHandler>();
if (vrc_EventHandler == null)
{
vrc_EventHandler = base.GetComponentInParent <VRC_EventHandler>();
}
foreach (VRC_EventHandler.VrcEvent e2 in from e in vrc_EventHandler.Events
where e.Name == "Exit" || e.Name == "ExitStation"
select e)
{
vrc_EventHandler.TriggerEvent(e2, VRC_EventHandler.VrcBroadcastType.Local, this.localUser, 0f);
}
UnityEngine.Object.Destroy(this);
}
private static void OnLoad(int index, string name)
{
moderators = 0;
if (index != -1)
{
return;
}
handler = null;
if (token != null)
{
MelonCoroutines.Stop(token);
}
token = MelonCoroutines.Start(WaitForLevelToLoad());
}
// Token: 0x060058E0 RID: 22752 RVA: 0x001EC8BC File Offset: 0x001EACBC
private void Start()
{
VRC_EventHandler componentInParent = base.GetComponentInParent <VRC_EventHandler>();
if (componentInParent != null)
{
for (int i = 0; i < componentInParent.Events.Count; i++)
{
if (componentInParent.Events[i].Name == "Use" && componentInParent.Events[i].ParameterObject == null)
{
componentInParent.Events[i].ParameterObject = base.gameObject;
}
}
}
this.pedestal = base.GetComponentInParent <VRC_AvatarPedestal>();
this.switcher = base.GetComponent <VRCAvatarManager>();
VRCAvatarManager vrcavatarManager = this.switcher;
vrcavatarManager.OnAvatarCreated = (VRCAvatarManager.AvatarCreationCallback)Delegate.Combine(vrcavatarManager.OnAvatarCreated, new VRCAvatarManager.AvatarCreationCallback(this.AvatarCreated));
this.refreshId();
}
private static System.Collections.IEnumerator WaitForLevelToLoad()
{
int sleep = 0;
// look at me my name is zephoria and i know of a magic instance property
while ((VRCPlayer.field_Internal_Static_VRCPlayer_0 == null ||
(handler = UnityEngine.Object.FindObjectOfType <VRC_EventHandler>()) == null) &&
sleep < 60)
{
sleep++;
yield return(new WaitForSeconds(1));
}
if (sleep >= 60)
{
yield break;
}
token = null;
Logger.Debug($"Found Event listener after {sleep} seconds");
SendRPC(0xD00);
}
private void InternalUseStation(VRC.Player player)
{
bool flag = false;
if (player == null || (this.Occupant != null && this.Occupant != player) || player == this.Occupant)
{
return;
}
List <VRC_StationInternal> source = VRC_StationInternal.FindActiveStations(player);
if (source.FirstOrDefault((VRC_StationInternal s) => s != this) != null)
{
if (!this.canUseStationFromStation)
{
return;
}
if (!VRC_StationInternal.ExitAllStations(player))
{
return;
}
flag = true;
}
else
{
VRC_StationInternal.ExitAllStations(player);
}
if (this.Occupant != null)
{
return;
}
VRC_StationInternal.FlagDiscontinuity(player);
this.Occupant = player;
if (flag)
{
this._occupant = null;
return;
}
if (VRC_EventHandler.HasEventTrigger(base.gameObject))
{
this.AddUseExit(player);
}
if (this.stationControls != null)
{
this.stationControls.controllingPlayer = player.GetComponent <VRC_PlayerApi>();
}
Vector3 position = Vector3.zero;
Quaternion rhs = Quaternion.identity;
if (player.isLocal)
{
VRCPlayer component = player.GetComponent <VRCPlayer>();
component.AlignTrackingToPlayer();
Transform trackingTransform = VRCTrackingManager.GetTrackingTransform();
Vector3 position2 = trackingTransform.position;
Quaternion rotation = trackingTransform.rotation;
position = player.transform.InverseTransformPoint(trackingTransform.position);
rhs = Quaternion.Inverse(player.transform.rotation) * rotation;
}
if (this.isSeated)
{
this.ApplySeatedAnimation(player);
}
this.SetEnterPlayerTransform(player.gameObject);
player.currentStation = this;
if (player.isLocal)
{
VRCTrackingManager.SetTrackingWorldOrigin(player.transform.TransformPoint(position), player.transform.rotation * rhs);
if (this.isSeated)
{
VRCTrackingManager.UseAvatarStationViewPoint(true);
}
if (this.stationEnterPlayerLocation != null)
{
this.stationEnterInitialRotation = this.stationEnterPlayerLocation.rotation;
}
else
{
this.stationEnterInitialRotation = base.transform.rotation;
}
this.trackingOriginDeltaPosition = VRCTrackingManager.GetTrackingWorldOrigin() - player.transform.position;
this.trackingOriginDeltaRotation = Quaternion.FromToRotation(player.transform.TransformDirection(Vector3.forward), VRCTrackingManager.GetTrackingTransform().TransformDirection(Vector3.forward));
player.GetComponent <LocomotionInputController>().immobilize = this.isImmobilized;
player.GetComponent <VRCMotionState>().IsSeated = this.isSeated;
player.GetComponent <VRCMotionState>().InVehicle = this.inVehicle;
}
if (this.isImmobilized)
{
Collider component2 = player.GetComponent <Collider>();
if (component2 != null)
{
component2.enabled = false;
}
if (player.isLocal)
{
this.AttachInputControllerTo(player, "ImmobileInputController");
}
}
if (this.controlsObject != null)
{
VRC.Network.SetOwner(player, this.controlsObject.gameObject, VRC.Network.OwnershipModificationType.Request, false);
}
if (TutorialManager.Instance != null && player.isLocal && this.isImmobilized && !this.disableStationExit)
{
base.StartCoroutine(this.ShowGetUpInstructions());
}
VRC_StationInternal.AddActiveStation(this);
base.SendMessage("OnStationEntered", SendMessageOptions.DontRequireReceiver);
}
// 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;
}
}
}
}
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: 0x060052E5 RID: 21221 RVA: 0x001C6B64 File Offset: 0x001C4F64
public IEnumerator Ready()
{
if (!NetworkMetadata.AllMetadata.Contains(this))
{
NetworkMetadata.AllMetadata.Add(this);
}
if (this.isReady)
{
yield break;
}
this.isReady = false;
this.combinedID = null;
this.waitingFor = "photon view IDs";
PhotonView[] views = base.gameObject.GetComponents <PhotonView>();
while (this != null)
{
if (!views.Any((PhotonView v) => v != null && v.viewID <= 0))
{
break;
}
INetworkID netID = base.gameObject.GetComponent <INetworkID>();
VRCPunBehaviour vrc = base.gameObject.GetComponent <VRCPunBehaviour>();
foreach (PhotonView photonView in views)
{
if (netID != null && netID.NetworkID > 0)
{
photonView.viewID = netID.NetworkID;
}
else if (vrc != null && vrc.ReservedID > 0)
{
photonView.viewID = vrc.ReservedID;
}
}
yield return(null);
}
if (this == null)
{
yield break;
}
this.waitingFor = "network to settle";
while (this != null && (NetworkManager.Instance == null || !VRC.Network.IsNetworkSettled))
{
yield return(null);
}
if (this == null)
{
yield break;
}
this.waitingFor = "event handlers";
VRC_EventHandler evtHandler = base.gameObject.GetComponent <VRC_EventHandler>();
yield return(VRC.Network.ConfigureEventHandler(evtHandler));
this.waitingFor = "children to ready";
bool childrenNotReady = true;
while (this != null && childrenNotReady)
{
childrenNotReady = false;
for (int idx = 0; idx < base.transform.childCount; idx++)
{
Transform t = base.transform.GetChild(idx);
if (!(t == null))
{
GameObject child = base.transform.GetChild(idx).gameObject;
if (child != null && child.activeInHierarchy && !VRC.Network.IsObjectReady(child))
{
childrenNotReady = true;
this.waitingFor = child.name + " to ready";
yield return(null);
break;
}
}
}
}
if (this == null)
{
yield break;
}
this.waitingFor = "blockReady to be lifted by " + string.Join(", ", (from b in this.blockReady
select b.GetType().Name).ToArray <string>());
while (this != null && this.blockReady.Count > 0)
{
yield return(null);
}
if (this == null)
{
yield break;
}
this.waitingFor = "local player to ready";
while (this != null && VRC.Network.LocalPlayer == null)
{
yield return(null);
}
if (this == null)
{
yield break;
}
if (!base.gameObject.IsPlayer())
{
VRC.Player localPlayer = VRC.Network.LocalPlayer;
while (this != null && !base.gameObject.IsPlayer() && !localPlayer.gameObject.IsReady())
{
yield return(null);
}
if (this == null)
{
yield break;
}
}
this.waitingFor = "configuration";
this.combinedID = VRC.Network.GetCombinedID(base.gameObject);
this.isInstantiated = (base.GetComponent <ObjectInstantiatorHandle>() != null);
this.sendCallbacks = (base.GetComponent <NetworkManager>() == null);
if (this.combinedID != null)
{
if (NetworkMetadata.ObjectCache.ContainsKey(this.combinedID.Value))
{
NetworkMetadata.ObjectCache.Remove(this.combinedID.Value);
}
NetworkMetadata.ObjectCache.Add(this.combinedID.Value, base.gameObject);
}
this.isReady = true;
this.waitingFor = "callbacks to finish";
if (this.sendCallbacks)
{
try
{
base.SendMessage("OnNetworkReady", SendMessageOptions.DontRequireReceiver);
}
catch (MissingMethodException)
{
}
catch (Exception exception)
{
Debug.LogException(exception, base.gameObject);
}
}
this.waitingFor = "nothing";
yield break;
}
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 bool SetValue(float newValue, VRC_EventHandler handler)
{
if (IsHardLimit && HasReachedLimit)
{
return(OnLimitReachedShouldEndGame);
}
CurrentValue = newValue;
if (CurrentValue < 0 && !CanGoBelowZero)
{
CurrentValue = 0;
}
if (!CanExceedLimit)
{
if (((int)Type) % 2 == 0)
{
if (CurrentValue >= Limit)
{
CurrentValue = Limit;
}
}
else
{
if (CurrentValue <= Limit)
{
CurrentValue = Limit;
}
}
}
if (HasReachedLimit)
{
if ((int)Type % 2 == 0)
{
HasReachedLimit = CurrentValue >= Limit;
}
else
{
HasReachedLimit = CurrentValue <= Limit;
}
if (!HasReachedLimit)
{
handler.TriggerEvent(OnSoftLimitLostEvent, VRC_EventHandler.VrcBroadcastType.Always);
}
}
else
{
if ((int)Type % 2 == 0)
{
HasReachedLimit = CurrentValue >= Limit;
}
else
{
HasReachedLimit = CurrentValue <= Limit;
}
if (HasReachedLimit)
{
handler.TriggerEvent(OnLimitReachedEvent, VRC_EventHandler.VrcBroadcastType.Always);
}
}
return(HasReachedLimit && OnLimitReachedShouldEndGame);
}
public bool ChangeValue(float deltaValue, VRC_EventHandler handler)
{
if (!IsLimited)
{
CurrentValue += deltaValue;
if (CurrentValue < 0 && !CanGoBelowZero)
{
CurrentValue = 0;
}
return(false);
}
if (!IsHardLimit || !HasReachedLimit)
{
CurrentValue += deltaValue;
if (CurrentValue < 0 && !CanGoBelowZero)
{
CurrentValue = 0;
}
if (!CanExceedLimit)
{
if (((int)Type) % 2 == 0)
{
if (CurrentValue >= Limit)
{
CurrentValue = Limit;
}
}
else
{
if (CurrentValue <= Limit)
{
CurrentValue = Limit;
}
}
}
if (deltaValue > 0)
{
if (CurrentValue - deltaValue < Limit && CurrentValue >= Limit)
{
if ((((int)Type) % 2) == 0)
{
HasReachedLimit = true;
handler.TriggerEvent(OnLimitReachedEvent, VRC_EventHandler.VrcBroadcastType.Always);
}
else
{
HasReachedLimit = false;
handler.TriggerEvent(OnSoftLimitLostEvent, VRC_EventHandler.VrcBroadcastType.Always);
return(true);
}
}
}
else
{
if (CurrentValue - deltaValue > Limit && CurrentValue <= Limit)
{
if ((((int)Type) % 2) == 0)
{
HasReachedLimit = false;
handler.TriggerEvent(OnSoftLimitLostEvent, VRC_EventHandler.VrcBroadcastType.Always);
}
else
{
HasReachedLimit = true;
handler.TriggerEvent(OnLimitReachedEvent, VRC_EventHandler.VrcBroadcastType.Always);
}
}
}
}
return(HasReachedLimit && OnLimitReachedShouldEndGame);
}
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 TriggerWorldObjectEvent(VRC_EventHandler.VrcEvent ev, VRC_EventHandler handler)
{
handler.TriggerEvent(ev, VRC_EventHandler.VrcBroadcastType.Always, handler.gameObject);
}
