private static void CreateInstance()
{
GameObject executor = new GameObject(CYAN_EMU_GAMEOBJECT_NAME_);
executor.tag = EDITOR_ONLY_TAG_;
instance_ = executor.AddComponent <CyanEmuMain>();
}
private void SpawnObject(Vector3 position, Quaternion rotation)
{
this.Log("Spawning Object " + objectSpawn_.ObjectPrefab.name + " at " + position + " and rotataion " + rotation);
GameObject spawnedObject = CyanEmuMain.SpawnObject(objectSpawn_.ObjectPrefab, position, rotation);
spawnedObjects_.Add(spawnedObject);
}
private void DrawGeneralSettings()
{
EditorGUILayout.BeginVertical(boxStyle_);
showGeneralSettings_ = EditorGUILayout.Foldout(showGeneralSettings_, generalFoldoutGuiContent);
if (showGeneralSettings_)
{
if (settings_.enableCyanEmu && FindObjectOfType <VRC_SceneDescriptor>() == null)
{
EditorGUILayout.HelpBox("No VRC_SceneDescriptor in scene. Please add one to enable CyanEmu.", MessageType.Warning);
}
if (settings_.enableCyanEmu && Application.isPlaying && !CyanEmuMain.HasInstance())
{
EditorGUILayout.HelpBox("Please exit and reenter play mode to enable CyanEmu!", MessageType.Warning);
}
settings_.enableCyanEmu = EditorGUILayout.Toggle(enableToggleGuiContent, settings_.enableCyanEmu);
EditorGUI.BeginDisabledGroup(!settings_.enableCyanEmu);
settings_.displayLogs = EditorGUILayout.Toggle(displayLogsToggleGuiContent, settings_.displayLogs);
}
EditorGUILayout.EndVertical();
}
public static void InitializePlayer(VRCPlayerApi player)
{
int id = nextPlayerID;
player.Log("Assigning player id " + id);
++nextPlayerID;
playerIDs[player] = id;
players[id] = player;
player.AddToList();
if (masterID == -1)
{
player.Log("Player is now master");
masterID = id;
Debug.Assert(player.isMaster, "CyanEmuPlayerManager:InitializePlayer Player should be considered master!");
}
else
{
Debug.Assert(!player.isMaster, "CyanEmuPlayerManager:InitializePlayer Player should not be considered master!");
}
Debug.Assert(player.playerId == id, "CyanEmuPlayerManager:InitializePlayer Player's id does not match assigned id!");
if (networkReady)
{
CyanEmuMain.PlayerJoined(player);
}
else
{
waitingPlayers.Add(player);
}
}
public void OnNetworkReady()
{
// Go through all buffered triggers first
if (settings_.replayBufferedTriggers)
{
CyanEmuMain.SpawnPlayer(false);
this.Log("Executing Buffered Triggers");
// This is hacky <_<
networkReady_ = true;
bufferManager_.ReplayTriggers();
networkReady_ = false;
}
FireTriggerTypeInternal(VRC_Trigger.TriggerType.OnNetworkReady);
networkReady_ = true;
this.Log("Executing Deferred Triggers");
foreach (VRC_Trigger.TriggerEvent evt in deferredTriggers_)
{
// Prevent deleted triggers from throwing errors.
if (GetTriggerForEvent(evt) == null)
{
continue;
}
ExecuteTrigger(evt);
}
deferredTriggers_.Clear();
}
public static void OnInit(UdonBehaviour behaviour, IUdonProgram program)
{
CyanEmuUdonHelper helper = behaviour.gameObject.AddComponent <CyanEmuUdonHelper>();
helper.SetUdonBehaviour(behaviour);
NetworkReadyFieldInfo_.SetValue(behaviour, CyanEmuMain.IsNetworkReady());
}
protected virtual void Awake()
{
originalPosition_ = transform.position;
originalRotation_ = transform.rotation;
rigidbody_ = GetComponent <Rigidbody>();
CyanEmuMain.AddSyncedObject(this);
}
public static void OnNetworkReady()
{
networkReady = true;
foreach (var player in waitingPlayers)
{
CyanEmuMain.PlayerJoined(player);
}
waitingPlayers.Clear();
}
public void Respawn()
{
if (currentStation_ != null)
{
currentStation_.ExitStation();
}
CloseMenu();
Teleport(descriptor_.spawns[0], false);
CyanEmuMain.PlayerRespawned(player_.player);
}
public void Respawn()
{
if (currentStation_ != null)
{
currentStation_.ExitStation();
}
CloseMenu();
Teleport(CyanEmuMain.GetNextSpawnPoint(), false);
CyanEmuMain.PlayerRespawned(player_.player);
}
public static void RemovePlayer(VRCPlayerApi player)
{
playerIDs.Remove(player);
players.Remove(player.playerId);
player.RemoveFromList();
if (masterID == player.playerId)
{
masterID = -1;
if (VRCPlayerApi.AllPlayers.Count != 0)
{
masterID = VRCPlayerApi.AllPlayers[0].playerId;
}
}
CyanEmuMain.PlayerLeft(player);
}
private void Awake()
{
if (instance_ != null)
{
this.LogError("Already have an instance of CyanEmu!");
DestroyImmediate(gameObject);
return;
}
settings_ = CyanEmuSettings.Instance;
instance_ = this;
DontDestroyOnLoad(this);
proxyObjectParents_ = new GameObject(CYAN_EMU_GAMEOBJECT_NAME_ + "ProxyObjects").transform;
DontDestroyOnLoad(proxyObjectParents_);
CyanEmuInputModule.DisableOtherInputModules();
gameObject.AddComponent <CyanEmuBaseInput>();
gameObject.AddComponent <CyanEmuInputModule>();
descriptor_ = FindObjectOfType <VRC_SceneDescriptor>();
if (descriptor_ == null)
{
Debug.LogWarning("There is no VRC_SceneDescriptor in the scene.");
}
// SDK manager class
#if VRC_SDK_VRCSDK2
sdkManager_ = gameObject.AddComponent <CyanEmuTriggerExecutor>();
#endif
#if UDON
sdkManager_ = gameObject.AddComponent <CyanEmuUdonManager>();
#endif
StartCoroutine(OnNetworkReady());
}
private void OnDestroy()
{
CyanEmuMain.RemoveSyncedObject(this);
}
static CyanEmuMain()
{
if (!CyanEmuSettings.Instance.enableCyanEmu || FindObjectOfType <PipelineSaver>() != null || !Application.isPlaying)
{
return;
}
VRCStation.Initialize += CyanEmuStationHelper.InitializeStations;
VRCStation.useStationDelegate = CyanEmuStationHelper.UseStation;
VRCStation.exitStationDelegate = CyanEmuStationHelper.ExitStation;
VRC_UiShape.GetEventCamera = CyanEmuPlayerController.GetPlayerCamera;
VRC_Pickup.OnAwake = CyanEmuPickupHelper.InitializePickup;
VRC_Pickup.ForceDrop = CyanEmuPickupHelper.ForceDrop;
VRC_Pickup._GetCurrentPlayer = CyanEmuPickupHelper.GetCurrentPlayer;
VRC_Pickup._GetPickupHand = CyanEmuPickupHelper.GetPickupHand;
VRC_ObjectSpawn.Initialize = CyanEmuObjectSpawnHelper.InitializeSpawner;
#if UDON
VRC.Udon.UdonBehaviour.OnInit = CyanEmuUdonHelper.OnInit;
VRC.Udon.UdonBehaviour.SendCustomNetworkEventHook = CyanEmuUdonHelper.SendCustomNetworkEventHook;
#endif
#if VRC_SDK_VRCSDK2
VRC_Trigger.InitializeTrigger = new Action <VRC_Trigger>(CyanEmuTriggerHelper.InitializeTrigger);
VRCSDK2.VRC_ObjectSync.Initialize += CyanEmuObjectSyncHelper.InitializeObjectSync;
VRCSDK2.VRC_ObjectSync.TeleportHandler += CyanEmuObjectSyncHelper.TeleportTo;
VRCSDK2.VRC_ObjectSync.RespawnHandler += CyanEmuObjectSyncHelper.RespawnObject;
VRCSDK2.VRC_PlayerMods.Initialize = CyanEmuPlayerModsHelper.InitializePlayerMods;
VRCSDK2.VRC_SyncAnimation.Initialize = CyanEmuSyncAnimationHelper.InitializationDelegate;
#endif
Networking._IsMaster = CyanEmuPlayerManager.IsLocalPlayerMaster;
Networking._LocalPlayer = CyanEmuPlayerManager.LocalPlayer;
Networking._GetOwner = CyanEmuPlayerManager.GetOwner;
Networking._IsOwner = CyanEmuPlayerManager.IsOwner;
Networking._SetOwner = CyanEmuPlayerManager.TakeOwnership;
Networking._GetUniqueName = VRC.Tools.GetGameObjectPath;
VRCPlayerApi._GetPlayerId = CyanEmuPlayerManager.GetPlayerID;
VRCPlayerApi._GetPlayerById = CyanEmuPlayerManager.GetPlayerByID;
VRCPlayerApi._isMasterDelegate = CyanEmuPlayerManager.IsMaster;
VRCPlayerApi.ClaimNetworkControl = CyanEmuPlayerManager.ClaimNetworkControl;
VRCPlayerApi._EnablePickups = CyanEmuPlayerManager.EnablePickups;
VRCPlayerApi._Immobilize = CyanEmuPlayerManager.Immobilize;
VRCPlayerApi._TeleportTo = CyanEmuPlayerManager.TeleportTo;
VRCPlayerApi._TeleportToOrientation = CyanEmuPlayerManager.TeleportToOrientation;
VRCPlayerApi._TeleportToOrientationLerp = CyanEmuPlayerManager.TeleportToOrientationLerp;
VRCPlayerApi._PlayHapticEventInHand = CyanEmuPlayerManager.PlayHapticEventInHand;
VRCPlayerApi._GetPlayerByGameObject = CyanEmuPlayerManager.GetPlayerByGameObject;
VRCPlayerApi._GetPickupInHand = CyanEmuPlayerManager.GetPickupInHand;
VRCPlayerApi._GetTrackingData = CyanEmuPlayerManager.GetTrackingData;
VRCPlayerApi._GetBoneTransform = CyanEmuPlayerManager.GetBoneTransform;
VRCPlayerApi._GetBonePosition = CyanEmuPlayerManager.GetBonePosition;
VRCPlayerApi._GetBoneRotation = CyanEmuPlayerManager.GetBoneRotation;
VRCPlayerApi._TakeOwnership = CyanEmuPlayerManager.TakeOwnership;
VRCPlayerApi._IsOwner = CyanEmuPlayerManager.IsOwner;
VRCPlayerApi._ClearPlayerTags = CyanEmuPlayerManager.ClearPlayerTag;
VRCPlayerApi._SetPlayerTag = CyanEmuPlayerManager.SetPlayerTag;
VRCPlayerApi._GetPlayerTag = CyanEmuPlayerManager.GetPlayerTag;
VRCPlayerApi._GetPlayersWithTag = CyanEmuPlayerManager.GetPlayersWithTag;
VRCPlayerApi._SetSilencedToTagged = CyanEmuPlayerManager.SetSilencedToTagged;
VRCPlayerApi._SetSilencedToUntagged = CyanEmuPlayerManager.SetSilencedToUntagged;
VRCPlayerApi._ClearSilence = CyanEmuPlayerManager.ClearSilence;
VRCPlayerApi._SetInvisibleToTagged = CyanEmuPlayerManager.SetInvisibleToTagged;
VRCPlayerApi._SetInvisibleToUntagged = CyanEmuPlayerManager.SetInvisibleToUntagged;
VRCPlayerApi._ClearInvisible = CyanEmuPlayerManager.ClearInvisible;
VRCPlayerApi._IsUserInVR = (VRCPlayerApi _) => false; // TODO one day...
VRCPlayerApi._GetRunSpeed = CyanEmuPlayerManager.GetRunSpeed;
VRCPlayerApi._SetRunSpeed = CyanEmuPlayerManager.SetRunSpeed;
VRCPlayerApi._GetWalkSpeed = CyanEmuPlayerManager.GetWalkSpeed;
VRCPlayerApi._SetWalkSpeed = CyanEmuPlayerManager.SetWalkSpeed;
VRCPlayerApi._GetJumpImpulse = CyanEmuPlayerManager.GetJumpImpulse;
VRCPlayerApi._SetJumpImpulse = CyanEmuPlayerManager.SetJumpImpulse;
VRCPlayerApi._GetVelocity = CyanEmuPlayerManager.GetVelocity;
VRCPlayerApi._SetVelocity = CyanEmuPlayerManager.SetVelocity;
VRCPlayerApi._GetPosition = CyanEmuPlayerManager.GetPosition;
VRCPlayerApi._GetRotation = CyanEmuPlayerManager.GetRotation;
VRCPlayerApi._GetGravityStrength = CyanEmuPlayerManager.GetGravityStrength;
VRCPlayerApi._SetGravityStrength = CyanEmuPlayerManager.SetGravityStrength;
VRCPlayerApi.IsGrounded = CyanEmuPlayerManager.IsGrounded;
VRCPlayerApi._UseAttachedStation = CyanEmuPlayerManager.UseAttachedStation;
VRCPlayerApi._UseLegacyLocomotion = CyanEmuPlayerManager.UseLegacyLocomotion;
VRCPlayerApi._CombatSetup = CyanEmuCombatSystemHelper.CombatSetup;
VRCPlayerApi._CombatSetMaxHitpoints = CyanEmuCombatSystemHelper.CombatSetMaxHitpoints;
VRCPlayerApi._CombatGetCurrentHitpoints = CyanEmuCombatSystemHelper.CombatGetCurrentHitpoints;
VRCPlayerApi._CombatSetRespawn = CyanEmuCombatSystemHelper.CombatSetRespawn;
VRCPlayerApi._CombatSetDamageGraphic = CyanEmuCombatSystemHelper.CombatSetDamageGraphic;
VRCPlayerApi._CombatGetDestructible = CyanEmuCombatSystemHelper.CombatGetDestructible;
VRCPlayerApi._CombatSetCurrentHitpoints = CyanEmuCombatSystemHelper.CombatSetCurrentHitpoints;
GameObject executor = new GameObject(CYAN_EMU_GAMEOBJECT_NAME_);
executor.tag = "EditorOnly";
instance_ = executor.AddComponent <CyanEmuMain>();
}
private void DrawPlayerButtons()
{
EditorGUILayout.BeginVertical(boxStyle_);
showPlayerButtons_ = EditorGUILayout.Foldout(showPlayerButtons_, playerButtonsFoldoutGuiContent, true);
if (showPlayerButtons_)
{
AddIndent();
// custom name
settings_.customLocalPlayerName = EditorGUILayout.TextField(localPlayerCustomNameGuiContent, settings_.customLocalPlayerName);
settings_.isInstanceOwner = EditorGUILayout.Toggle(isInstanceOwnerGuiContent, settings_.isInstanceOwner);
// TODO have setting for spawning players in the room before you
EditorGUI.BeginDisabledGroup(!CyanEmuMain.HasInstance() || !Application.isPlaying);
/*
* EditorGUI.BeginDisabledGroup(CyanEmuPlayerController.instance != null);
*
* if (GUILayout.Button("Spawn Local Player"))
* {
* CyanEmuMain.SpawnPlayer(true);
* }
*
* EditorGUI.EndDisabledGroup();
*/
remotePlayerCustomName = EditorGUILayout.TextField(remotePlayerCustomNameGuiContent, remotePlayerCustomName);
if (GUILayout.Button("Spawn Remote Player"))
{
CyanEmuMain.SpawnPlayer(false, remotePlayerCustomName);
}
List <VRCPlayerApi> playersToRemove = new List <VRCPlayerApi>();
if (Application.isPlaying)
{
foreach (var player in VRCPlayerApi.AllPlayers)
{
GUILayout.BeginHorizontal();
GUILayout.Label(player.displayName);
GUILayout.Space(5);
EditorGUI.BeginDisabledGroup(VRCPlayerApi.AllPlayers.Count == 1 || player.isLocal);
if (GUILayout.Button("Remove Player"))
{
playersToRemove.Add(player);
}
EditorGUI.EndDisabledGroup();
GUILayout.EndHorizontal();
}
for (int i = playersToRemove.Count - 1; i >= 0; --i)
{
CyanEmuMain.RemovePlayer(playersToRemove[i]);
}
playersToRemove.Clear();
}
EditorGUI.EndDisabledGroup();
RemoveIndent();
}
EditorGUILayout.EndVertical();
}
protected virtual void OnDisable()
{
CyanEmuMain.RemoveSyncedObject(this);
}
private void Awake()
{
if (instance != null)
{
this.LogError("Player controller instance already exists!");
DestroyImmediate(this);
return;
}
#if VRC_SDK_VRCSDK2
legacyLocomotion_ = true;
#endif
instance = this;
descriptor_ = FindObjectOfType <VRC_SceneDescriptor>();
gameObject.layer = LayerMask.NameToLayer("PlayerLocal");
gameObject.tag = "Player";
rigidbody_ = gameObject.AddComponent <Rigidbody>();
rigidbody_.isKinematic = true;
characterController_ = gameObject.AddComponent <CharacterController>();
characterController_.slopeLimit = 50;
characterController_.stepOffset = .5f;
characterController_.skinWidth = 0.005f;
characterController_.minMoveDistance = 0;
characterController_.center = new Vector3(0, 0.8f, 0);
characterController_.radius = 0.2f;
characterController_.height = 1.6f;
GameObject capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule);
capsule.transform.localScale = new Vector3(0.4f, 1, 0.4f);
capsule.transform.SetParent(transform, false);
capsule.transform.localPosition = new Vector3(0, 1, 0);
capsule.layer = LayerMask.NameToLayer("MirrorReflection");
DestroyImmediate(capsule.GetComponent <Collider>());
playerCamera_ = new GameObject("Player Camera");
GameObject cameraHolder = new GameObject("CameraHolder");
cameraHolder.transform.SetParent(playerCamera_.transform, false);
camera_ = cameraHolder.AddComponent <Camera>();
camera_.cullingMask &= ~(1 << 18); // remove mirror reflection
updateStancePosition_ = false;
// TODO, make based on avatar armspan/settings
cameraHolder.transform.localScale = Vector3.one * AVATAR_SCALE_;
playerCamera_.AddComponent <AudioListener>();
playerCamera_.transform.SetParent(transform, false);
playerCamera_.transform.localPosition = new Vector3(0, STANDING_HEIGHT_, .1f);
playerCamera_.transform.localRotation = Quaternion.identity;
playspace_ = new GameObject("Playspace Center");
playspace_.transform.SetParent(transform, false);
playspace_.transform.localPosition = new Vector3(-1, 0, -1);
playspace_.transform.localRotation = Quaternion.Euler(0, 45, 0);
rightArmPosition_ = new GameObject("Right Arm Position");
rightArmPosition_.transform.SetParent(playerCamera_.transform, false);
rightArmPosition_.transform.localPosition = new Vector3(0.15f, -0.13f, 0.4f);
rightArmPosition_.transform.localRotation = Quaternion.Euler(-35, 0, -90);
rightArmRigidbody_ = rightArmPosition_.AddComponent <Rigidbody>();
rightArmRigidbody_.isKinematic = true;
leftArmPosition_ = new GameObject("Left Arm Position");
leftArmPosition_.transform.SetParent(playerCamera_.transform, false);
leftArmPosition_.transform.localPosition = new Vector3(-0.15f, -0.13f, 0.4f);
leftArmPosition_.transform.localRotation = Quaternion.Euler(-35, 0, -90);
leftArmRigidbody_ = leftArmPosition_.AddComponent <Rigidbody>();
leftArmRigidbody_.isKinematic = true;
mouseLook_ = new MouseLook();
mouseLook_.Init(transform, playerCamera_.transform);
stance_ = Stance.STANDING;
baseInput_ = transform.parent.gameObject.GetComponent <CyanEmuBaseInput>();
CreateMenu();
GameObject interactHelper = new GameObject("InteractHelper");
interactHelper.transform.SetParent(transform.parent, false);
interactHelper_ = interactHelper.AddComponent <CyanEmuInteractHelper>();
Func <bool> shouldCheckForInteracts = () => { return(currentPickup_ == null && !menu_.activeInHierarchy && !isDead_); };
interactHelper_.Initialize(playerCamera_.transform, playerCamera_.transform, shouldCheckForInteracts);
reticleTexture_ = Resources.Load <Texture2D>("Images/Reticle");
cameraProxyObject_ = new GameObject("CameraDamageProxy").transform;
cameraProxyObject_.SetParent(CyanEmuMain.GetProxyObjectTransform(), false);
UpdateCameraProxyPosition();
// experimental!
//interactHelper_.highlightManager = playerCamera_.AddComponent<VRCP_HighlightManager>();
}
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)
{
}
}
protected virtual void OnEnable()
{
CyanEmuMain.AddSyncedObject(this);
}
