712 lines
20 KiB
C#
712 lines
20 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public class changePlayerStateOnTriggerSystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool changePlayerStatesEnabled = true;
|
|
|
|
public bool disableTriggerAfterEnter;
|
|
|
|
[Space]
|
|
[Header ("Player Mode Settings")]
|
|
[Space]
|
|
|
|
public bool changePlayerMode;
|
|
|
|
public string playerModeName;
|
|
|
|
[Space]
|
|
[Header ("Jump Settings")]
|
|
[Space]
|
|
|
|
public bool setJumpEnabledState;
|
|
public bool jumpEnabledState;
|
|
|
|
public bool setDoubleJumpState;
|
|
public bool doubleJumpState;
|
|
|
|
[Space]
|
|
[Header ("Camera Settings")]
|
|
[Space]
|
|
|
|
public bool setCameraViewState;
|
|
public bool setCameraToFirstPerson;
|
|
|
|
public bool setNewDefaultThirdPersonCameraState;
|
|
public string newDefaultThirdPersonCameraStateName;
|
|
|
|
public bool setActionToChangeBetweenViewsState;
|
|
public bool actionToChangeBetweenViewsState;
|
|
|
|
public bool setCameraStateName;
|
|
public string cameraStateName;
|
|
|
|
public bool resetCameraRotationState;
|
|
|
|
[Space]
|
|
[Header ("Input Settings")]
|
|
[Space]
|
|
|
|
public bool setPlayerInputActionState;
|
|
public bool playerInputActionState;
|
|
public string multiAxesInputName;
|
|
public string axesInputName;
|
|
|
|
[Space]
|
|
|
|
public bool setIgnoreCheckInputActiveState;
|
|
public bool ignoreCheckInputActiveState;
|
|
public List<string> multiAxesInputNameList;
|
|
|
|
[Space]
|
|
|
|
public bool setPauseAllInputActionsState;
|
|
public bool pauseAllInputActionState;
|
|
|
|
[Space]
|
|
|
|
public bool setPauseMovementAxisInputState;
|
|
public bool pauseMovementAxisInputState;
|
|
|
|
public bool setPauseCameraAxisInputState;
|
|
public bool pauseCameraAxisInputState;
|
|
|
|
[Space]
|
|
[Header ("Animation Settings")]
|
|
[Space]
|
|
|
|
public bool setActionActiveState;
|
|
public bool actionActiveState;
|
|
public int actionId = -1;
|
|
|
|
[Space]
|
|
|
|
public bool enableAnimatorLayerOnAction;
|
|
public string animatorLayerToEnableName;
|
|
|
|
[Space]
|
|
[Header ("Weapon Settings")]
|
|
[Space]
|
|
|
|
public bool drawWeapon;
|
|
public bool drawCurrentWeapon;
|
|
|
|
[Space]
|
|
|
|
public bool drawCertainWeapon;
|
|
public string weaponNameToDraw;
|
|
public bool isFireWeapon;
|
|
|
|
[Space]
|
|
|
|
public bool keepWeapon;
|
|
|
|
[Space]
|
|
[Header ("Fire Weapon Settings")]
|
|
[Space]
|
|
|
|
public bool setCarryWeaponOnLowerPositionState;
|
|
public bool carryWeaponOnLowerPositionState;
|
|
public bool setCanFireWeaponsState;
|
|
public bool canFireWeaponsState;
|
|
|
|
[Space]
|
|
[Header ("Gravity Settings")]
|
|
[Space]
|
|
|
|
public bool setGravityPowerState;
|
|
public bool gravityPowerState;
|
|
|
|
public bool setZeroGravityModeState;
|
|
public bool zeroGravityModeState;
|
|
|
|
public bool setGravityDirection;
|
|
public setGravity setGravityManager;
|
|
|
|
[Space]
|
|
[Header ("Free Floating Mode Settings")]
|
|
[Space]
|
|
|
|
public bool setFreeFloatingModeState;
|
|
public bool freeFloatingModeState;
|
|
|
|
[Space]
|
|
[Header ("Look At Target Settings")]
|
|
[Space]
|
|
|
|
public bool setLookAtPointState;
|
|
public bool lookAtPointState;
|
|
public Transform pointToLook;
|
|
public bool useDurationToLookAtPoint;
|
|
public float durationToLookAtPoint;
|
|
public bool enableLookAtPointStateAfterDuration;
|
|
public bool setLookAtPointSpeed;
|
|
public float lookAtPointSpeed;
|
|
|
|
public bool setMaxDistanceToFindTarget;
|
|
public float maxDistanceToFindTarget;
|
|
|
|
public bool setUseLookTargetIconState;
|
|
public bool useLookTargetIconState;
|
|
|
|
public bool setOriginalUseLookTargetIconState;
|
|
|
|
[Space]
|
|
[Header ("Camera Zoom Settings")]
|
|
[Space]
|
|
|
|
public bool setCameraZoomState;
|
|
public bool cameraZoomState;
|
|
public bool useCameraZoomDuration;
|
|
public float cameraZoomDuration;
|
|
public bool enableCameraZoonInputAfterDuration;
|
|
|
|
[Space]
|
|
[Header ("Transparent Surface Detection Settings")]
|
|
[Space]
|
|
|
|
public bool setTransparentSurfaceDetectionState;
|
|
public bool transparentSurfaceDetectionState;
|
|
|
|
[Space]
|
|
[Header ("Movement Settings")]
|
|
[Space]
|
|
|
|
public bool setWalkSpeedValue;
|
|
public float walkSpeedValue;
|
|
public bool setOriginalWalkSpeedValue;
|
|
|
|
public bool setIncreaseWalkSpeedValue;
|
|
public float increaseWalkSpeedValue;
|
|
|
|
public bool setIncreaseWalkSpeedEnabled;
|
|
public bool increaseWalkSpeedEnabled;
|
|
public bool setOriginalIncreaseWalkSpeedEnabledValue;
|
|
|
|
public bool setPlayerStatusID;
|
|
public int playerStatusID;
|
|
public bool setOriginalPlayerStatusID;
|
|
|
|
public bool setCrouchState;
|
|
public bool crouchStateToActivate;
|
|
|
|
[Space]
|
|
[Header ("Sprint Settings")]
|
|
[Space]
|
|
|
|
public bool setSprintEnabledState;
|
|
public bool sprintEnabledState;
|
|
public bool setOriginalSprintEnabledState;
|
|
|
|
[Space]
|
|
[Header ("Stairs Settings")]
|
|
[Space]
|
|
|
|
public bool setStairsAdherenceValue;
|
|
public float stairsMaxValue = 0.25f;
|
|
public float stairsMinValue = 0.2f;
|
|
public float stairsGroundAdherence = 8;
|
|
|
|
[Space]
|
|
[Header ("Root Motion Settings")]
|
|
[Space]
|
|
|
|
public bool changeRootMotionActive;
|
|
public bool useRootMotionActive = true;
|
|
|
|
[Space]
|
|
[Header ("Ragdoll Settings")]
|
|
[Space]
|
|
|
|
public bool activateRagdollState;
|
|
public Transform ragdollPushDirection;
|
|
public float ragdollPushForceAmount;
|
|
|
|
[Space]
|
|
[Header ("Ability Settings")]
|
|
[Space]
|
|
|
|
public bool setAbility;
|
|
public string abilityNameToSet;
|
|
|
|
[Space]
|
|
|
|
public bool useAbilitiesListToEnable;
|
|
|
|
public List<string> abilitiesListToEnable = new List<string> ();
|
|
|
|
[Space]
|
|
|
|
public bool useAbilitiesListToDisable;
|
|
|
|
public List<string> abilitiesListToDisable = new List<string> ();
|
|
|
|
[Space]
|
|
[Header ("Powers Settings")]
|
|
[Space]
|
|
|
|
public bool setCurrentPower;
|
|
public string currentPowerName;
|
|
|
|
[Space]
|
|
[Header ("Map Settings")]
|
|
[Space]
|
|
|
|
public bool setCompassEnableValue;
|
|
public bool compassEnabledValue;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
[Space]
|
|
[Space]
|
|
|
|
[Space]
|
|
[Header ("Remote Events Settings")]
|
|
[Space]
|
|
|
|
public bool useRemoteEventOnObjectsFound;
|
|
public List<string> removeEventNameList = new List<string> ();
|
|
|
|
[Space]
|
|
[Header ("Event Settings")]
|
|
[Space]
|
|
|
|
public bool useEventOnTrigger;
|
|
public UnityEvent eventOnTrigger;
|
|
public bool sendPlayerOnEvent;
|
|
public eventParameters.eventToCallWithGameObject playerSendEvent;
|
|
|
|
[Space]
|
|
[Header ("Player Manual Settings")]
|
|
[Space]
|
|
|
|
public bool setPlayerManually;
|
|
public GameObject playerToConfigure;
|
|
|
|
public GameObject currentPlayer;
|
|
|
|
public bool searchPlayerOnSceneIfNotAssigned = true;
|
|
|
|
playerComponentsManager mainPlayerComponentsManager;
|
|
playerController playerControllerManager;
|
|
playerCamera playerCameraManager;
|
|
playerWeaponsManager weaponsManager;
|
|
inventoryManager mainInventoryManager;
|
|
meleeWeaponsGrabbedManager mainMeleeWeaponsGrabbedManager;
|
|
|
|
gravitySystem gravityManager;
|
|
playerInputManager playerInput;
|
|
Collider currentCollider;
|
|
grabObjects grabObjectsManager;
|
|
playerAbilitiesSystem mainPlayerAbilitySystem;
|
|
remoteEventSystem currentRemoteEventSystem;
|
|
otherPowers mainOtherPowers;
|
|
playerStatesManager mainPlayerStatesManager;
|
|
ragdollActivator mainRagdollActivator;
|
|
mapSystem mainMapSystem;
|
|
|
|
|
|
void Start ()
|
|
{
|
|
if (setPlayerManually) {
|
|
setCurrentPlayer (playerToConfigure);
|
|
}
|
|
}
|
|
|
|
public void findPlayerOnScene ()
|
|
{
|
|
if (searchPlayerOnSceneIfNotAssigned) {
|
|
setCurrentPlayer (GKC_Utils.findMainPlayerOnScene ());
|
|
}
|
|
}
|
|
|
|
public void setCurrentPlayer (GameObject player)
|
|
{
|
|
currentPlayer = player;
|
|
}
|
|
|
|
public void changePlayerState ()
|
|
{
|
|
if (currentPlayer == null) {
|
|
|
|
findPlayerOnScene ();
|
|
|
|
if (currentPlayer == null) {
|
|
print ("WARNING: no player controller has been assigned to the change player state on trigger." +
|
|
" Make sure to use a trigger to activate the element or assign the player manually");
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!changePlayerStatesEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (currentPlayer == null) {
|
|
return;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("current character detected " + currentPlayer.name);
|
|
}
|
|
|
|
mainPlayerComponentsManager = currentPlayer.GetComponent<playerComponentsManager> ();
|
|
|
|
if (mainPlayerComponentsManager == null) {
|
|
return;
|
|
}
|
|
|
|
//get all the components needed
|
|
playerControllerManager = mainPlayerComponentsManager.getPlayerController ();
|
|
|
|
if (playerControllerManager == null) {
|
|
return;
|
|
}
|
|
|
|
playerCameraManager = mainPlayerComponentsManager.getPlayerCamera ();
|
|
|
|
weaponsManager = mainPlayerComponentsManager.getPlayerWeaponsManager ();
|
|
|
|
mainInventoryManager = mainPlayerComponentsManager.getInventoryManager ();
|
|
|
|
mainMeleeWeaponsGrabbedManager = mainPlayerComponentsManager.getMeleeWeaponsGrabbedManager ();
|
|
|
|
gravityManager = mainPlayerComponentsManager.getGravitySystem ();
|
|
|
|
playerInput = mainPlayerComponentsManager.getPlayerInputManager ();
|
|
|
|
currentCollider = playerControllerManager.getMainCollider ();
|
|
|
|
grabObjectsManager = mainPlayerComponentsManager.getGrabObjects ();
|
|
|
|
mainPlayerAbilitySystem = mainPlayerComponentsManager.getPlayerAbilitiesSystem ();
|
|
|
|
currentRemoteEventSystem = mainPlayerComponentsManager.getRemoteEventSystem ();
|
|
|
|
mainOtherPowers = mainPlayerComponentsManager.getOtherPowers ();
|
|
|
|
mainPlayerStatesManager = mainPlayerComponentsManager.getPlayerStatesManager ();
|
|
|
|
mainRagdollActivator = mainPlayerComponentsManager.getRagdollActivator ();
|
|
|
|
mainMapSystem = mainPlayerComponentsManager.getMapSystem ();
|
|
|
|
|
|
//Player Mode Settings
|
|
if (changePlayerMode) {
|
|
mainPlayerStatesManager.setPlayerModeByName (playerModeName);
|
|
}
|
|
|
|
//Jump settings
|
|
if (setJumpEnabledState) {
|
|
playerControllerManager.enableOrDisableJump (jumpEnabledState);
|
|
}
|
|
|
|
if (setDoubleJumpState) {
|
|
playerControllerManager.enableOrDisableDoubleJump (doubleJumpState);
|
|
}
|
|
|
|
|
|
//Camera settings
|
|
if (setCameraViewState) {
|
|
playerCameraManager.changeCameraToThirdOrFirstView (setCameraToFirstPerson);
|
|
}
|
|
|
|
if (setActionToChangeBetweenViewsState) {
|
|
playerCameraManager.enableOrDisableChangeCameraView (actionToChangeBetweenViewsState);
|
|
}
|
|
|
|
if (setCameraStateName) {
|
|
if (!playerCameraManager.isFirstPersonActive ()) {
|
|
playerCameraManager.setCameraStateExternally (cameraStateName);
|
|
}
|
|
}
|
|
|
|
if (setNewDefaultThirdPersonCameraState) {
|
|
playerCameraManager.setDefaultThirdPersonStateName (newDefaultThirdPersonCameraStateName);
|
|
}
|
|
|
|
if (resetCameraRotationState) {
|
|
playerCameraManager.resetCameraRotation ();
|
|
}
|
|
|
|
//Weapon settings
|
|
if (drawWeapon) {
|
|
if (drawCurrentWeapon) {
|
|
GKC_Utils.drawOrHolsterWeapon (currentPlayer, true, "", false);
|
|
}
|
|
|
|
if (drawCertainWeapon) {
|
|
GKC_Utils.drawOrHolsterWeapon (currentPlayer, true, weaponNameToDraw, isFireWeapon);
|
|
}
|
|
}
|
|
|
|
if (keepWeapon) {
|
|
GKC_Utils.drawOrHolsterWeapon (currentPlayer, false, "", false);
|
|
}
|
|
|
|
if (setCarryWeaponOnLowerPositionState) {
|
|
if (carryWeaponOnLowerPositionState) {
|
|
weaponsManager.setCarryWeaponInLowerPositionActiveState (true);
|
|
|
|
grabObjectsManager.enableOrDisableGeneralCursorFromExternalComponent (false);
|
|
} else {
|
|
weaponsManager.setCarryWeaponInLowerPositionActiveState (false);
|
|
|
|
grabObjectsManager.enableOrDisableGeneralCursorFromExternalComponent (true);
|
|
}
|
|
}
|
|
|
|
if (setCanFireWeaponsState) {
|
|
weaponsManager.setFireWeaponsInputActiveState (canFireWeaponsState);
|
|
}
|
|
|
|
//Gravity settings
|
|
if (setGravityPowerState) {
|
|
gravityManager.setGravityPowerEnabledState (gravityPowerState);
|
|
}
|
|
|
|
if (setZeroGravityModeState) {
|
|
gravityManager.setZeroGravityModeOnState (zeroGravityModeState);
|
|
}
|
|
|
|
if (setFreeFloatingModeState) {
|
|
gravityManager.setfreeFloatingModeOnState (freeFloatingModeState);
|
|
}
|
|
|
|
if (setGravityDirection) {
|
|
setGravityManager.checkTriggerType (currentCollider, true);
|
|
}
|
|
|
|
if (setPlayerInputActionState) {
|
|
playerInput.setPlayerInputActionState (playerInputActionState, multiAxesInputName, axesInputName);
|
|
}
|
|
|
|
if (setIgnoreCheckInputActiveState) {
|
|
playerInput.setIgnoreCheckInputActiveStateOnList (ignoreCheckInputActiveState, multiAxesInputNameList);
|
|
}
|
|
|
|
if (setPauseAllInputActionsState) {
|
|
playerInput.setIgnoreAllActionsInputState (pauseAllInputActionState);
|
|
}
|
|
|
|
if (setPauseMovementAxisInputState) {
|
|
playerInput.setMovementAxisInputPausedState (pauseMovementAxisInputState);
|
|
}
|
|
|
|
if (setPauseCameraAxisInputState) {
|
|
playerInput.setCameraAxisInputPausedState (pauseCameraAxisInputState);
|
|
}
|
|
|
|
if (setActionActiveState) {
|
|
playerControllerManager.setActionActiveExternally (actionActiveState);
|
|
|
|
if (actionId != -1) {
|
|
playerControllerManager.setNewActionIDExternally (actionId);
|
|
}
|
|
|
|
if (enableAnimatorLayerOnAction) {
|
|
playerControllerManager.enableAnimatorLayerWeight (animatorLayerToEnableName);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if (setUseLookTargetIconState) {
|
|
playerCameraManager.setUseLookTargetIconState (useLookTargetIconState);
|
|
}
|
|
|
|
//Player camera look at point settings
|
|
if (setLookAtPointState) {
|
|
if (lookAtPointState) {
|
|
playerCameraManager.setLookAtTargetEnabledState (true);
|
|
}
|
|
|
|
if (setMaxDistanceToFindTarget) {
|
|
playerCameraManager.setMaxDistanceToFindTargetValue (maxDistanceToFindTarget);
|
|
}
|
|
|
|
playerCameraManager.setLookAtTargetStateManual (lookAtPointState, pointToLook);
|
|
|
|
if (lookAtPointState) {
|
|
playerCameraManager.setLookAtTargetEnabledState (false);
|
|
}
|
|
|
|
if (setLookAtPointSpeed) {
|
|
playerCameraManager.setLookAtTargetSpeedValue (lookAtPointSpeed);
|
|
}
|
|
|
|
if (useDurationToLookAtPoint) {
|
|
playerCameraManager.setLookAtTargetEnabledStateDuration (false, durationToLookAtPoint, enableLookAtPointStateAfterDuration);
|
|
}
|
|
|
|
if (setMaxDistanceToFindTarget) {
|
|
playerCameraManager.setOriginalmaxDistanceToFindTargetValue ();
|
|
}
|
|
}
|
|
|
|
if (setOriginalUseLookTargetIconState) {
|
|
playerCameraManager.setOriginalUseLookTargetIconValue ();
|
|
}
|
|
|
|
//Camera zoom settings
|
|
if (setCameraZoomState) {
|
|
playerCameraManager.setZoom (cameraZoomState);
|
|
|
|
if (useCameraZoomDuration) {
|
|
playerCameraManager.setZoomStateDuration (false, cameraZoomDuration, enableCameraZoonInputAfterDuration);
|
|
}
|
|
}
|
|
|
|
|
|
//Transparent Surface Detection Settings
|
|
if (setTransparentSurfaceDetectionState) {
|
|
setTransparentSurfaces currentSetTransparentSurfaces = mainPlayerComponentsManager.getSetTransparentSurfaces ();
|
|
|
|
if (currentSetTransparentSurfaces != null) {
|
|
currentSetTransparentSurfaces.setCheckSurfaceActiveState (transparentSurfaceDetectionState);
|
|
}
|
|
}
|
|
|
|
|
|
//Sprint settings
|
|
if (setSprintEnabledState) {
|
|
if (setOriginalSprintEnabledState) {
|
|
playerControllerManager.setOriginalSprintEnabledValue ();
|
|
} else {
|
|
if (!sprintEnabledState) {
|
|
playerControllerManager.stopSprint ();
|
|
}
|
|
|
|
playerControllerManager.setSprintEnabledState (sprintEnabledState);
|
|
}
|
|
}
|
|
|
|
|
|
//Movements settings
|
|
if (setWalkSpeedValue) {
|
|
if (setOriginalWalkSpeedValue) {
|
|
playerControllerManager.setOriginalWalkSpeed ();
|
|
} else {
|
|
playerControllerManager.setWalkSpeedValue (walkSpeedValue);
|
|
}
|
|
}
|
|
|
|
if (setIncreaseWalkSpeedEnabled) {
|
|
if (setOriginalIncreaseWalkSpeedEnabledValue) {
|
|
playerControllerManager.setOriginalIncreaseWalkSpeedEnabledValue ();
|
|
} else {
|
|
playerControllerManager.setIncreaseWalkSpeedEnabled (increaseWalkSpeedEnabled);
|
|
}
|
|
}
|
|
|
|
if (setIncreaseWalkSpeedValue) {
|
|
playerControllerManager.setIncreaseWalkSpeedValue (increaseWalkSpeedValue);
|
|
}
|
|
|
|
if (setPlayerStatusID) {
|
|
if (setOriginalPlayerStatusID) {
|
|
playerControllerManager.resetPlayerStatusID ();
|
|
} else {
|
|
playerControllerManager.setPlayerStatusIDValue (playerStatusID);
|
|
}
|
|
}
|
|
|
|
if (setCrouchState) {
|
|
if (crouchStateToActivate) {
|
|
if (!playerControllerManager.isCrouching ()) {
|
|
playerControllerManager.setCrouchState (true);
|
|
}
|
|
} else {
|
|
if (playerControllerManager.isCrouching ()) {
|
|
playerControllerManager.setCrouchState (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Stairs settings
|
|
if (setStairsAdherenceValue) {
|
|
playerControllerManager.setStairsValues (stairsMaxValue, stairsMinValue, stairsGroundAdherence);
|
|
}
|
|
|
|
|
|
//Root motion settings
|
|
if (changeRootMotionActive) {
|
|
playerControllerManager.setUseRootMotionActiveState (useRootMotionActive);
|
|
}
|
|
|
|
|
|
//Ragdoll settings
|
|
if (activateRagdollState) {
|
|
Vector3 pushDirection = transform.forward;
|
|
|
|
if (ragdollPushDirection != null) {
|
|
pushDirection = ragdollPushDirection.forward;
|
|
}
|
|
|
|
mainRagdollActivator.pushCharacter (pushDirection * ragdollPushForceAmount);
|
|
}
|
|
|
|
|
|
//Ability settings
|
|
if (setAbility) {
|
|
mainPlayerAbilitySystem.setCurrentAbilityByName (abilityNameToSet);
|
|
}
|
|
|
|
if (useAbilitiesListToEnable) {
|
|
mainPlayerAbilitySystem.enableOrDisableAbilityGroupByName (abilitiesListToEnable, true);
|
|
|
|
GKC_Utils.setUnlockStateOnSkillList (currentPlayer.transform, abilitiesListToEnable, true);
|
|
}
|
|
|
|
if (useAbilitiesListToDisable) {
|
|
mainPlayerAbilitySystem.enableOrDisableAbilityGroupByName (abilitiesListToDisable, false);
|
|
}
|
|
|
|
//Powers settings
|
|
if (setCurrentPower) {
|
|
mainOtherPowers.setCurrentPowerByName (currentPowerName);
|
|
}
|
|
|
|
//Map Settings
|
|
if (setCompassEnableValue) {
|
|
if (mainMapSystem != null) {
|
|
mainMapSystem.setCompassEnabledStateAndUpdateState (compassEnabledValue);
|
|
}
|
|
}
|
|
|
|
//Remote Event Settings
|
|
if (useRemoteEventOnObjectsFound) {
|
|
if (currentRemoteEventSystem != null) {
|
|
for (int i = 0; i < removeEventNameList.Count; i++) {
|
|
currentRemoteEventSystem.callRemoteEvent (removeEventNameList [i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//Events to be called after any state is triggred
|
|
if (sendPlayerOnEvent) {
|
|
playerSendEvent.Invoke (currentPlayer);
|
|
}
|
|
|
|
if (useEventOnTrigger) {
|
|
eventOnTrigger.Invoke ();
|
|
}
|
|
|
|
if (disableTriggerAfterEnter) {
|
|
gameObject.SetActive (false);
|
|
}
|
|
}
|
|
}
|