private void CollisionSettings(Trigger triggerObject)
    {
        using (new Vertical("box"))
        {
            GUILayout.Space(3f);
            showCollisionSettings = EditorGUILayout.Foldout(showCollisionSettings, "Collision Settings");

            GUILayout.Space(5f);

            if (showCollisionSettings)
            {
                if ((triggerObject.triggerType & Trigger.TriggerType.Collision) != 0)
                {
                    EditorGUILayout.PropertyField(impactForceThreshold, new GUIContent("Impact Force Threshold", "This is the minimum force required from a collision to trigger any fracture components this object is linked to.  Setting this to 0 would effectively make any collision trigger the fracture."));

                    EditorGUILayout.Separator();

                    EditorGUILayout.PropertyField(onlyTriggerWithTag, new GUIContent("Only Trigger With Tag", "If this checkbox is ticked, this object will only be triggered if the tag of the colliding object is the same as below."));
                    if(onlyTriggerWithTag.boolValue)
                    {
                        triggerTag.stringValue = EditorGUILayout.TagField(new GUIContent("Trigger Tag", "The desired tag to use for masking collisions by tag."), triggerTag.stringValue);
                    }
                }
                else
                {
                    using (new GUIColor(new Color(1.0f, 0.3f, 0.3f)))
                    {
                        GUILayout.Label("To use the collision settings, you must have enabled the collision trigger type.", EditorStyles.miniBoldLabel);
                    }
                }
            }
            GUILayout.Space(3f);
        }
    }

 static bool ActionIsTriggered(Trigger trigger, Settings  settings)
 {
     return 
            ((trigger == Trigger.New && settings.TrackingTriggerOnNew) ||
             ((trigger == Trigger.Update) && settings.TrackingTriggerOnUpdate) ||
             ((trigger == Trigger.Delete) && settings.TrackingTriggerOnDelete));
 }

    public override void On(Trigger trigger)
    {
        base.On(trigger);

        World = Root.Instance.SenseManager.GetLayerItem("World");
        Player = Root.Instance.SenseManager.GetLayerItem("Player");

        if (World == null)
        {
            return;
        }

        if (Player != null)
        {
            playerPos = Player.transform.position;

            if (trigger != null && trigger.Item != null)
            {
                playerPos = trigger.Item.transform.position;
            }
        }

        startTime = Time.time;
        startRotation = World.transform.rotation.eulerAngles;
        endRotation = EndRotation;
    }

 public static void AddTrigger(Trigger trigger)
 {
     if (triggers == null) {
         triggers = new List<Trigger>();
     }
     triggers.Add(trigger);
 }

 protected virtual void OnTrigger(Trigger pTrigger)
 {
     if(m_Trigger != null && (m_Trigger.gameObject == pTrigger.gameObject))
     {
         Trigger();
     }
 }

        public Trigger[] Load(IDbConnection connection)
        {
            var triggers = new List<Trigger>();

            using (var command = connection.CreateCommand())
            {
                command.CommandText = "SELECT T.[object_id], T.[name], M.[definition] FROM sys.triggers T, sys.sql_modules M WHERE T.[object_id] = M.[object_id]";

                using (var reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        int objectId = reader.GetInt32(reader.GetOrdinal("object_id"));
                        string name = reader.GetString(reader.GetOrdinal("name"));
                        int definitionOrdinal = reader.GetOrdinal("definition");
                        string definition = reader.IsDBNull(definitionOrdinal) ? null : reader.GetString(definitionOrdinal);

                        var view = new Trigger(name, definition) {ObjectId = objectId};
                        triggers.Add(view);
                    }
                }
            }

            triggers.Sort((x, y) => string.CompareOrdinal(x.Name, y.Name));
            return triggers.ToArray();
        }

		public override void SetUp()
		{
			base.SetUp();

			mockJobStore = Mocks.CreateMock<IJobStore>();
			mockJobRunner = Mocks.CreateMock<IJobRunner>();
			mockLogger = Mocks.CreateMock<ILogger>();
			mockTrigger = Mocks.PartialMock<Trigger>();
			scheduler = new DefaultScheduler(mockJobStore, mockJobRunner);

			dummyJobData = new JobData();
			dummyJobSpec = new JobSpec("foo", "bar", "key", mockTrigger);
			dummyJobDetails = new JobDetails(dummyJobSpec, DateTime.UtcNow);

			isWoken = false;

			// Ensure the scheduler is initialized.
			mockJobStore.RegisterScheduler(scheduler.Guid, scheduler.Name);
			Mocks.Replay(mockJobStore);
			scheduler.Initialize();
			Mocks.Verify(mockJobStore);
			Mocks.BackToRecord(mockJobStore);

			mockJobStore.UnregisterScheduler(scheduler.Guid);

			// Create a separate uninitialized scheduler for certain tests.
			uninitializedScheduler = new DefaultScheduler(mockJobStore, mockJobRunner);
		}

 public override void perform(GameObject instigator, Trigger trig)
 {
     RobotController robot = parent.GetComponent<RobotController>();
     if(robot != null) {
         robot.dispose();
     }
 }

 public void JobScheduled(Trigger trigger)
 {
     foreach (ISchedulerListener l in listeners)
     {
         l.JobScheduled(trigger);
     }
 }

    // Use this for initialization
    protected void Start()
    {
        Action[] actions =  gameObject.GetComponents<Action>() as Action[];
        Trigger = gameObject.GetComponent<Trigger>();
        if (Trigger == null)
        {
            Debug.Log("No Trigger found." + gameObject.name + " interaction not initilized!");
            return;
        }

        if (actions == null)
        {
            Debug.Log("No actions found." + gameObject.name + " interaction not initilized!");
            return;
        }
        foreach (Action action in actions)
        {
            if (Interactions == null)
            {
                Interactions = new List<Action>();
            }
            Interactions.Add(action);
            Debug.Log("Adding interaction: " + action.GetType());
            Trigger.OnTriggerActivated += action.OnTriggerActivated;
            Trigger.OnTriggerDeactivated += action.OnTriggerDeactivated;

        }
    }

        public PencilGamingWindows(int width, int height, string title, bool isFullscreen, bool shouldVsync)
        {
            onWindowOpened = new Trigger<PencilGamingWindows>();
            OnWindowOpened = onWindowOpened;

            onWindowClosed = new Trigger<PencilGamingWindows>();
            OnWindowClosed = onWindowClosed;

            onWindowResized = new Trigger<PencilGamingWindows>();
            OnWindowResized = onWindowResized;

            onKeyboard = new Trigger<PencilKeyInfo>();
            OnKeyboard = onKeyboard;

            onExit = new Trigger<PencilGamingWindows>();
            OnExit = onExit;

            window = GlfwWindowPtr.Null;
            this.width = width;
            this.height = height;
            this.title = title;
            this.isFullscreen = isFullscreen;
            this.shouldVsync = shouldVsync;
            this.firstTime = true;
            if (!Glfw.Init())
            {
                Console.Error.WriteLine("ERROR: Could not initialize GLFW, shutting down.");
                Environment.Exit(1);
            }
        }

        public InputComponent(Game game)
            : base(game)
        {
            InteractTrigger = new Trigger<bool>();
            ApplyTrigger = new Trigger<bool>();
            InventoryTrigger = new Trigger<bool>();
            JumpTrigger = new Trigger<bool>();
            SlotLeftTrigger = new Trigger<bool>();
            SlotRightTrigger = new Trigger<bool>();
            SlotTrigger = new Trigger<bool>[SlotTriggerLength];
            for (int i = 0; i < SlotTrigger.Length; i++)
                SlotTrigger[i] = new Trigger<bool>();

            gamepad = new GamePadInput();
            keyboard = new KeyboardInput();
            mouse = new MouseInput(game);
            screenMouse = new MouseScreenInput();
            screenKeyboard = new KeyboardScreenInput();

            screenKeyboard.OnKeyDown += (key) => { if (OnKeyDown != null) OnKeyDown(key); };
            screenKeyboard.OnKeyUp += (key) => { if (OnKeyUp != null) OnKeyUp(key); };
            screenMouse.OnLeftMouseUp += (position) => { if (OnLeftMouseUp != null) OnLeftMouseUp(position); };

            inputDevices = new List<IInputSet>{
                gamepad,
                keyboard,
                mouse
            };

            screenInputDevices = new List<IScreenInputSet>{
                screenMouse
            };
        }

    public override void On(Trigger trigger)
    {
        enable("hear");

        base.On(trigger);
        Debug.Log("HearSense");
    }

 private void OnTrigger(Trigger pTrigger)
 {
     if(m_Trigger != null && (m_Trigger.gameObject == pTrigger.gameObject))
     {
         StartEmission ();
     }
 }

    void Start()
    {
        soundStopped = true;
        trigger = GetComponent<Trigger>();

        particles = GetComponent<ParticleSystem>();
    }

 override protected void SetDefaultTriggers()
 {
     SupportedTriggers = new Trigger[3]{
         AddHiddenComponent<EventTrigger>(),
         AddHiddenComponent<TrackTrigger>(),
         AddHiddenComponent<EventTrigger>()};
 }

 public override void perform(GameObject instigator, Trigger trig)
 {
     Player player = parent.GetComponent<Player>();
     if(player != null && !player.frozen) {
         player.die();
     }
 }

    public override void Off(Trigger trigger)
    {
        enable("blind");
        disable("look");

        base.Off(trigger);
    }

        private void button2_Click(object sender, RoutedEventArgs e)
        {
            Trigger t = new Trigger();
            t.Name = FileNameTextBox.Text;
            t.ID = IDTextBox.Text;
            t.Hash = BinaryEditor.HexStringToBytes(HashTextBox.Text);

            if (SizeLimitTextBox.Text.Trim() == "" || !Regex.IsMatch(SizeLimitTextBox.Text, "^[0-9]*$")) t.LimitSize = 0;
            else t.LimitSize = long.Parse(SizeLimitTextBox.Text);

            if (SizeLowerTextBox.Text.Trim() == "" || !Regex.IsMatch(SizeLowerTextBox.Text, "^[0-9]*$")) t.LowerSize = 0;
            else t.LowerSize = long.Parse(SizeLowerTextBox.Text);

            t.Category = new string[3] { "", "", "" };

            int i = 0;
            foreach (Match m in Regex.Matches(QueryTextBox.Text, "\"(.*?)\""))
            {
                if (i >= 3) break;
                t.Category[i] = m.Value.Trim('\"');
                i++;
            }

            t.Effect = EffectCheckBox.IsChecked == true ? true : false;
            t.Remove = TriggerDeleteCheckBox.IsChecked == true ? true : false;

            Settings.Default._triggerList.Add(t);

            this.DialogResult = true;
            this.Close();
        }

 public override void perform(GameObject instigator, Trigger trig)
 {
     LandMine mine = parent.GetComponent<LandMine>();
     if (mine != null) {
         mine.detonate();
     }
 }