public void DisplayObject(InteractionObject interactionObject)
    {
        // Run world behaviors resulting from interaction
        interactionObject.onInteractionBegin.Invoke(interactionObject);

        if (interactionObject.objectDialog != null)
        {
            dialog.SetDialogQueue(interactionObject.objectDialog);
            dialog.DisplayNextCard();
        }
        else if(interactionObject.objectConversation != null)
        {
            FindObjectOfType<ConversationManager>().RunConversation(interactionObject.objectConversation);
        }

        GameObject currentInspectedObject = null;

        if (interactionObject.isInspectable)
        {
            currentInspectedObject = (GameObject)Instantiate(interactionObject.objectToInspect, this.transform.position, Quaternion.Euler(interactionObject.interactionRotation));
            currentInspectedObject.transform.parent = this.transform;

            PlaceObjectToFit(currentInspectedObject);

            camera.enabled = true;
            cameraGrayscale.effectAmount = 1;
        }

        StartCoroutine(CloseInteractionCamera(interactionObject, currentInspectedObject));
    }

 protected Node ST_Approach(Transform target1, Transform target2, InteractionObject cp)
 {
     //foreach (GameObject n in chara) {
     Val<Vector3> position1 = Val.V (() => target1.position);
     Val<Vector3> position2 = Val.V (() => target2.position);
     //print ("hello");
     return new SequenceParallel (participant2.GetComponent<BehaviorMecanim> ().Node_GoTo (position1), participant1.GetComponent<BehaviorMecanim> ().Node_GoTo (position1));
 }

 private void OnInteractionFinish(
     FullBodyBipedEffector effector,
     InteractionObject obj)
 {
     if (this.finish == null)
         this.finish = new Dictionary<FullBodyBipedEffector, bool>();
     if (this.finish.ContainsKey(effector))
         this.finish[effector] = true;
 }

 private void OnInteractionTrigger(
     FullBodyBipedEffector effector, 
     InteractionObject obj)
 {
     if (this.triggers == null)
         this.triggers = new Dictionary<FullBodyBipedEffector, bool>();
     if (this.triggers.ContainsKey(effector))
         this.triggers[effector] = true;
 }

    public void AttemptExitEnd(InteractionObject obj)
    {
        if (numberOfPapers == 0)
        {
            var closeSound = obj.GetComponent<AudioSource>();
            if (closeSound != null)
                closeSound.Play();

            StartCoroutine(ExitCoroutine());
        }
    }

 public void GoToHallwayEnd(InteractionObject obj)
 {
     // Only load hallway if keycard has been found
     if (keycardFound)
     {
         StartCoroutine(ExitToHallwayCoroutine());
     }
     else
     {
         convoManager.RunConversation(keycardNotFoundConvo);
     }
 }    

    public void connectToObject(InteractionObject obj, InteractionPointConnectMethod connectMode = InteractionPointConnectMethod.MIRROR)
    {
        _interactionObject = obj;

        if (connectMode == InteractionPointConnectMethod.MIRROR) {
            connectToObjectMirror(obj);
        } else {
            if (connectMode == InteractionPointConnectMethod.SURFACE) {
                connectToObjectSurface(obj);
            } else {
                if (obj.isInsideW(_globalPosition, InteractionHand.SIZE) == (connectMode == InteractionPointConnectMethod.INSIDE)) {
                    connectToObjectMirror(obj);
                } else {
                    connectToObjectSurface(obj);
                }
            }
        }

        _isConnected = true;
    }

	void PickUp()
	{
		if(Input.GetKeyDown(KeyCode.P))//Input.GetKey("PickUp"))
		{
			float x = Screen.width /2; 
			float y = Screen.height/2;

			Ray ray = mainCam.ScreenPointToRay(new Vector3(x,y));
			RaycastHit hit;

			if(Physics.Raycast(ray, out hit))
			{
				selectedObject = hit.collider.GetComponent<InteractionObject>();
				if(selectedObject != null)
				{
					carrying = true;
					carryingObject = selectedObject.RBody;
				}
			}

		}
	}

 private void OnEffectorPickUp(
     FullBodyBipedEffector effectorType, 
     InteractionObject interactionObject)
 {
     if (this.InteractionPickUp != null)
         this.InteractionPickUp(this, effectorType, interactionObject);
 }

 protected Node ST_Get_Ball(GameObject picker, FullBodyBipedEffector effector, InteractionObject ball, string tracer)
 {
     Val<FullBodyBipedEffector> eff = Val.V(() => effector);
     Val<InteractionObject> ba = Val.V(() => ball);
     return new Sequence(
         new LeafTrace(tracer),
         picker.GetComponent<BehaviorMecanim>().Node_StartInteraction(eff, ba),
         new LeafWait(1000));
 }

 private void OnEffectorResume(
     FullBodyBipedEffector effectorType, 
     InteractionObject interactionObject)
 {
     if (this.InteractionResume != null)
         this.InteractionResume(this, effectorType, interactionObject);
 }

 public void AttemptExitStart(InteractionObject obj)
 {
     obj.objectDialog = numberOfPapers == 0 ? exitAllowed : exitNotAllowed;
 }

        private void PerformSwap(FullBodyBipedEffector effector, InteractionObject obj)
        {
            // Move all the effectors to the secondary IK solver
            foreach (var kv in this.primaryEffectors)
            {
                if (kv.Key != effector)
                {
                    this.handlerSecondary.StartInteraction(kv.Key, kv.Value, true);
                    this.secondaryEffectors[kv.Key] = kv.Value;
                }
            }
            this.handlerSecondary.StartInteraction(effector, obj, true);
            this.secondaryEffectors[effector] = obj;

            // Swap solvers
            this.Swap();

            // Store the intermediate state
            float time = Time.time;
            this.swapTimeFinish = time + this.SwapTime;
            this.state = BodyIKState.Swapping;
        }

 private void OnEffectorStart(
     FullBodyBipedEffector effectorType, 
     InteractionObject interactionObject)
 {
     if (this.InteractionStart != null)
         this.InteractionStart(this, effectorType, interactionObject);
 }

 public void LoadTheScene(InteractionObject obj)
 {
     SceneManager.LoadScene(scene);
 }

 private void OnInteractionTrigger(
     CrossfadeInteractionHandler handler,
     FullBodyBipedEffector effectorType,
     InteractionObject interactionObject)
 {
     if (this.BodyTrigger != null)
         this.BodyTrigger(effectorType, interactionObject);
 }

 private void OnInteractionRelease(
     FullBodyBipedEffector effectorType,
     InteractionObject interactionObject)
 {
     if (this.InteractionRelease != null)
         this.InteractionRelease(effectorType, interactionObject);
 }

    /// <summary>
    /// Starts the interaction between an effector and an interaction object.
    /// </summary>
    public void StartInteraction(
        FullBodyBipedEffector effectorType, 
        InteractionObject interactionObject, 
        bool interrupt)
    {
        if (!IsValid(true)) return;

        for (int i = 0; i < interactionEffectors.Length; i++)
        {
            if (interactionEffectors[i].effectorType == effectorType)
            {
                interactionEffectors[i].Start(
                    interactionObject,
                    targetTag,
                    fadeInTime,
                    interrupt);
                return;
            }
        }
    }

 public void GoToHallwayBegin(InteractionObject obj)
 {
     // Make sure no dialog runs
     obj.objectDialog = null;
 }

 public void FoundKeycard(InteractionObject obj)
 {
     keycardFound = true;
 }