void Start()
 {
     player = this.gameObject;
     playerCamera = GameObject.FindGameObjectWithTag(Tags.camera);
     playerRigidbody = GetComponent<Rigidbody>();
     playerInteraction = GetComponent<Interaction>();
 }

        public void ShouldReturnStrictMockOfCorrectType()
        {
            Interaction i = new Interaction();
            object mock = i.CreateStrictMock<StrictMockSpec>();

            Specify.That(mock.GetType().FullName).ShouldEqual("NBehave.Spec.Framework.Specification.Mocks.__Proxy__StrictMockSpec");
        }

        public void HandledInteractionsShouldNotCauseException()
        {
            var interaction = new Interaction<Unit, bool>();
            interaction.RegisterHandler(c => c.SetOutput(true));

            interaction.Handle(Unit.Default).FirstAsync().Wait();
        }

        public void ShouldCreateStrictInstanceOfInterfaceWithDefaultCtor()
        {
            Interaction i = new Interaction();
            IMockable fooMock = i.CreateStrictMock<IMockable>();

            Specify.That(fooMock).ShouldNotBeNull();
        }

 public void ChangeState(Interaction.interactionType type, bool b)
 {
     //Debug.Log(tag);
     switch (tag)
     {
         case "Openable":
             StartCoroutine(Open(b));
             break;
         case "Lightable":
             StartCoroutine(Light(b));
             break;
         case "InteractableWater":
             StartCoroutine(Water(b));
             break;
         case "InteractableRock":
             StartCoroutine(Rock(b));
             break;
         case "DeadTree":
             if(type == Interaction.interactionType.LEAVES)
             {
                 StartCoroutine(Leaves(b));
             }
             else
             {
                 StartCoroutine(Flower(b));
             }
             break;
     }
 }

        public void HandlersCanOptNotToHandleTheInteraction()
        {
            var interaction = new Interaction<bool, string>();

            var handler1A = interaction.RegisterHandler(x => x.SetOutput("A"));
            var handler1B = interaction.RegisterHandler(
                x => {
                    // only handle if the input is true
                    if (x.Input) {
                        x.SetOutput("B");
                    }
                });
            var handler1C = interaction.RegisterHandler(x => x.SetOutput("C"));

            using (handler1A) {
                using (handler1B) {
                    using (handler1C) {
                        Assert.Equal("C", interaction.Handle(false).FirstAsync().Wait());
                        Assert.Equal("C", interaction.Handle(true).FirstAsync().Wait());
                    }

                    Assert.Equal("A", interaction.Handle(false).FirstAsync().Wait());
                    Assert.Equal("B", interaction.Handle(true).FirstAsync().Wait());
                }

                Assert.Equal("A", interaction.Handle(false).FirstAsync().Wait());
                Assert.Equal("A", interaction.Handle(true).FirstAsync().Wait());
            }
        }

        public void ShouldCreateStrictInstanceOfAbstractType()
        {
            Interaction i = new Interaction();
            MockableBase fooBaseMock = i.CreateStrictMock<MockableBase>();

            Specify.That(fooBaseMock).ShouldNotBeNull();
        }

        private void Initialize(Interaction interaction)
        {
            try
            {
                // Create new session vm
                var sessionvm = new RecursiveLabsSessionViewModel(interaction);

                // Add urls to VM
                foreach (var url in RecursiveLabsButton.Urls)
                {
                    // Make sure it doesn't think it's selected
                    url.IsSelected = false;

                    // Add to list
                    sessionvm.Urls.Add(url);
                }

                // Set to data context
                DataContext = sessionvm;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                RecursiveLabsAddin.AddinTracer.Exception(ex);
            }
        }

 public TennisActor(string code, string prefab, Vector3 position, bool hidden, Interaction interaction)
     : base(position, hidden)
 {
     this.prefab = prefab;
     this.code = code;
     this.interaction = interaction;
 }

 private void InteractionRay()
 {
     RaycastHit ray;
     if (Physics.Raycast(cameraT.position, cameraT.forward, out ray, interactMaxDist, (int)Mathf.Pow(2, 8)))
     {
         Debug.DrawLine(cameraT.position, ray.point, Color.yellow, 0f, true);
         interaction = FindInteraction(ray);
         if (Input.GetButtonUp("Use"))
         {
             switch (interaction)
             {
                 case Interaction.Terminal:
                     Terminal terminal = ray.collider.GetComponent<Terminal>();
                     terminal.Use();
                     break;
                 case Interaction.Number:
                     GameFragment fragment = ray.collider.GetComponent<GameFragment>();
                     _Game.CollectNumber(fragment.Use());
                     break;
                 case Interaction.Collectable:
                     //break;
                 default:
                     break;
             }
         }
     }
     else
     {
         interaction = Interaction.None;
     }
 }

	// Use this for initialization
	void Start ()
    {

        playerInteraction = GameObject.FindGameObjectWithTag("Player").GetComponent<Interaction>();
        myText = this.GetComponent<Text>();

    }

    void Update()
    {
        if (interaction==null)
        {
            interaction = GameObject.Find("Player").transform.FindChild("Main Camera").GetComponent<Core>().interaction;
            if (interaction != null)
            {
                interaction.addInteractionObject(this.gameObject, delegate()
                {
                    OnMouseDown();
                }, delegate()
                {
                    gameObject.renderer.material = iluminated;
                }, delegate()
                {
                    gameObject.renderer.material = normal;
                });
            }
        }

        play = Mathf.PingPong(Time.time, 3);
        if (play > 2.9)
        {
            particle.emit = true	;
        }
        else
        {
            particle.emit = false;
        }
    }

    //    GameObject interactionObject;
    //    private Component interaction;
    // Use this for initialization
    void Start()
    {
        interaction = GameObject.Find ("Root").GetComponent <Interaction> ();

        // Call script to apply settings that depend on platform (eg touch vs mouse)
        if (!applyPlatformSettings ())
            interaction.debugMessage ("Platform settings failed", 3.0f);
    }

        public void UnhandledInteractionsShouldCauseException()
        {
            var interaction = new Interaction<string, Unit>();
            Assert.Throws<UnhandledInteractionException<string, Unit>>(() => interaction.Handle("foo").FirstAsync().Wait());

            interaction.RegisterHandler(_ => { });
            interaction.RegisterHandler(_ => { });
            Assert.Throws<UnhandledInteractionException<string, Unit>>(() => interaction.Handle("foo").FirstAsync().Wait());
        }

        public void ShouldReturnStrictMockWhenSupplyingCtorArgs()
        {
            Interaction i = new Interaction();
            StrictMockSpec mock = i.CreateStrictMock<StrictMockSpec>(5, "Test");

            Specify.That(mock.i).ShouldEqual(5);
            Specify.That(mock.s).ShouldEqual("Test");
            Specify.That(mock.GetType().FullName).ShouldEqual("NBehave.Spec.Framework.Specification.Mocks.__Proxy__StrictMockSpec");
        }

 void Start()
 {
     Cursor.lockState = CursorLockMode.Locked;
     Cursor.visible = false;
     player = GameObject.FindGameObjectWithTag(Tags.player);
     playerCamera = GameObject.FindGameObjectWithTag(Tags.camera).GetComponent<PlayerCamera>();
     playerMovement = player.GetComponent<PlayerMovement>();
     playerInteraction = player.GetComponent<Interaction>();
 }

        public new void LoopDel(StateMachineClient smc, Interaction<Sim, Computer>.LoopData loopData)
        {
            Journalism job = OmniCareer.Career<Journalism>(Actor.Occupation);

            Definition def = InteractionDefinition as Definition;
            if (job.UpdateReview(def.Review))
            {
                Actor.AddExitReason(ExitReason.Finished);
            }
        }

	//Unity Callbacks
	void Start()
	{
		AddObserver(GameManager.Instance);
		m_Statistics = new ActorStatistics(gameObject.GetComponent<Actor>());
		if (m_HUD != null)
		{
			m_HUD.InitializeBars();
		}
		m_Interaction = GetComponentInChildren<Interaction>();
	}

    public void AddInteraction(Interaction interaction)
    {
        if (interactions == null)
            interactions = new List<Interaction>();

        if (interactions.Find(i => i == interaction) == null)
            interactions.Add(interaction);
        else
            Debug.LogWarning("Trying to add an interaction "+interaction+" that is already added");
    }

        public FileListViewModel(IScreen host)
        {
            HostScreen = host;

            Files = new ReactiveList<string>(new []
            {
                "c:/temp/foo.txt",
                "c:/temp/bar.txt",
                "c:/temp/baseball.dat",
                "c:/temp/basketball.dat",
                "c:/temp/handegg.dat"
            });

            var confirmDelete = new Interaction<Unit, string>();

            DeleteFile = ReactiveCommand.CreateFromTask(
                async () =>
                {
                    var fileToDelete = SelectedFile;
                    var baseMessage = $"Do you really want to delete {fileToDelete}?";
                    var help = "\nConfirm by entering the full file name below.";
                    var message = baseMessage + help;
                    var abort = this
                        .WhenAnyValue(x => x.SelectedFile)
                        .Skip(1)
                        .Select(_ => Unit.Default);

                    ConfirmDeleteViewModel = new ConfirmEventViewModel(abort, confirmDelete)
                    {
                        Message = message
                    };

                    while (true)
                    {
                        var confirmation = await confirmDelete.Handle(Unit.Default);

                        if (confirmation == fileToDelete)
                        {
                            SelectedFile = null;
                            Files.Remove(fileToDelete);
                            ConfirmDeleteViewModel = null;
                            break;
                        }

                        if (confirmation == null)
                        {
                            ConfirmDeleteViewModel = null;
                            break;
                        }

                        ConfirmDeleteViewModel.Message = baseMessage + "\nYou didn't type the right thing." + help;
                    }
                },
                this.WhenAnyValue(vm => vm.SelectedFile).Select(s => s != null));
        }