# Table of Contents - [RaySensor | SensorToolkit 2](#raysensor-sensortoolkit-2) - [LOSSensor | SensorToolkit 2](#lossensor-sensortoolkit-2) - [BooleanSensor | SensorToolkit 2](#booleansensor-sensortoolkit-2) - [FOVCollider | SensorToolkit 2](#fovcollider-sensortoolkit-2) - [NavMeshSensor | SensorToolkit 2](#navmeshsensor-sensortoolkit-2) - [Sensor | SensorToolkit 2](#sensor-sensortoolkit-2) - [ArcSensor | SensorToolkit 2](#arcsensor-sensortoolkit-2) - [RangeSensor | SensorToolkit 2](#rangesensor-sensortoolkit-2) - [Introduction | SensorToolkit 2](#introduction-sensortoolkit-2) - [What's Included? | SensorToolkit 2](#what-s-included-sensortoolkit-2) - [Upgrading from V1 | SensorToolkit 2](#upgrading-from-v1-sensortoolkit-2) - [2D Components | SensorToolkit 2](#2d-components-sensortoolkit-2) - [Signal Processor | SensorToolkit 2](#signal-processor-sensortoolkit-2) - [FOV Collider | SensorToolkit 2](#fov-collider-sensortoolkit-2) - [Quickstart Tutorial | SensorToolkit 2](#quickstart-tutorial-sensortoolkit-2) - [Signal Proxy | SensorToolkit 2](#signal-proxy-sensortoolkit-2) - [AI Tree | SensorToolkit 2](#ai-tree-sensortoolkit-2) - [Behavior Designer | SensorToolkit 2](#behavior-designer-sensortoolkit-2) - [Game Creator 2 | SensorToolkit 2](#game-creator-2-sensortoolkit-2) - [TriggerSensor | SensorToolkit 2](#triggersensor-sensortoolkit-2) - [SteeringSensor | SensorToolkit 2](#steeringsensor-sensortoolkit-2) - [UserSignals | SensorToolkit 2](#usersignals-sensortoolkit-2) - [Signal | SensorToolkit 2](#signal-sensortoolkit-2) - [Fundamentals | SensorToolkit 2](#fundamentals-sensortoolkit-2) - [Playmaker | SensorToolkit 2](#playmaker-sensortoolkit-2) - [Arc Sensor | SensorToolkit 2](#arc-sensor-sensortoolkit-2) - [Range Sensor | SensorToolkit 2](#range-sensor-sensortoolkit-2) - [Trigger Sensor | SensorToolkit 2](#trigger-sensor-sensortoolkit-2) - [Line of Sight Sensor | SensorToolkit 2](#line-of-sight-sensor-sensortoolkit-2) - [Boolean Sensor | SensorToolkit 2](#boolean-sensor-sensortoolkit-2) - [Ray Sensor | SensorToolkit 2](#ray-sensor-sensortoolkit-2) - [NavMesh Sensor | SensorToolkit 2](#navmesh-sensor-sensortoolkit-2) - [Steering Sensor | SensorToolkit 2](#steering-sensor-sensortoolkit-2) - [User Signals | SensorToolkit 2](#user-signals-sensortoolkit-2) - [404 Not Found](#404-not-found) --- # RaySensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/ray#) On this page Detects objects intersected by a raycast. Subclass of [`Sensor`](https://micosmo.com/sensortoolkit2/docs/api/sensor) . Properties[​](https://micosmo.com/sensortoolkit2/docs/api/ray#properties "Direct link to heading") --------------------------------------------------------------------------------------------------- ### `Shape`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#shape "Direct link to heading") Can be one of `Ray`, `Sphere`, `Box` or `Capsule`, or 2D analogues for 2D version of the sensor. The shape that is cast along the ray. ### `Sphere`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#sphere "Direct link to heading") Configuration parameters for the `Sphere` shape. ### `Box`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#box "Direct link to heading") Configuration parameters for the `Box` shape. ### `Capsule`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#capsule "Direct link to heading") Configuration parameters for the `Capsule` shape. ### `Length`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#length "Direct link to heading") The detection range of the sensor. The length that the ray is cast. ### `Direction`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#direction "Direct link to heading") The vector direction that the ray is cast in. ### `WorldSpace`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#worldspace "Direct link to heading") Specifies the `Direction` vector should be interpreted in local-space or world-space. ### `DetectsOnLayers`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#detectsonlayers "Direct link to heading") A layer mask specifying which physics layers objects will be detected on. ### `ObstructedByLayers`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#obstructedbylayers "Direct link to heading") A layer mask specifying which physics layers objects will obstruct the ray on. ### `DetectionMode`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#detectionmode "Direct link to heading") * **`Colliders`** - sensor will detect the `Collider.gameObject`. * **`RigidBodies`** - sensor will detect the `Collider.attachedRigidBody.gameObject`. ### `Filter`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#filter "Direct link to heading") Configuration for filters including _Ignore List_ and _Tag Filter_. ### `IgnoreTriggerColliders`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#ignoretriggercolliders "Direct link to heading") Ignores all trigger colliders. Will not detect them or be obstructed by them. ### `MinimumSlopeAngle`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#minimumslopeangle "Direct link to heading") Calculated slope angle must be greater for the intersection to be a detection or an obstruction. ### `SlopeUpDirection`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#slopeupdirection "Direct link to heading") Measure slope angle between this direction and the _Normal_ of the `RayCastHit`. Interpreted in world-space. ### `PulseMode`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#pulsemode "Direct link to heading") One of `EachFrame`, `FixedInterval` or `Manual`. ### `PulseInterval`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#pulseinterval "Direct link to heading") If `PulseMode` is set to `FixedInterval`, this is the time in seconds between each pulse. ### `IsObstructed`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#isobstructed "Direct link to heading") Boolean specifying if the ray is currently obstructed. Events[​](https://micosmo.com/sensortoolkit2/docs/api/ray#events "Direct link to heading") ------------------------------------------------------------------------------------------- ### `OnObstruction`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#onobstruction "Direct link to heading") `UnityEvent` invoked when the sensor is obstructed and was previously unobstructed. ### `OnClear`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#onclear "Direct link to heading") `UnityEvent` invoked when the sensor becomes unobstructed when it was previously obstructed. Methods[​](https://micosmo.com/sensortoolkit2/docs/api/ray#methods "Direct link to heading") --------------------------------------------------------------------------------------------- ### `GetDetectionRayHit(gameObject)`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#getdetectionrayhitgameobject "Direct link to heading") `RayHit GetDetectionRayHit(GameObject detectedGameObject)` Returns the `RayHit` data for the given detected `GameObject`. ### `GetObstructionRayHit()`[​](https://micosmo.com/sensortoolkit2/docs/api/ray#getobstructionrayhit "Direct link to heading") `RayHit GetObstruction()` Returns `RayHit` data for the current obstruction. * [Properties](https://micosmo.com/sensortoolkit2/docs/api/ray#properties) * [`Shape`](https://micosmo.com/sensortoolkit2/docs/api/ray#shape) * [`Sphere`](https://micosmo.com/sensortoolkit2/docs/api/ray#sphere) * [`Box`](https://micosmo.com/sensortoolkit2/docs/api/ray#box) * [`Capsule`](https://micosmo.com/sensortoolkit2/docs/api/ray#capsule) * [`Length`](https://micosmo.com/sensortoolkit2/docs/api/ray#length) * [`Direction`](https://micosmo.com/sensortoolkit2/docs/api/ray#direction) * [`WorldSpace`](https://micosmo.com/sensortoolkit2/docs/api/ray#worldspace) * [`DetectsOnLayers`](https://micosmo.com/sensortoolkit2/docs/api/ray#detectsonlayers) * [`ObstructedByLayers`](https://micosmo.com/sensortoolkit2/docs/api/ray#obstructedbylayers) * [`DetectionMode`](https://micosmo.com/sensortoolkit2/docs/api/ray#detectionmode) * [`Filter`](https://micosmo.com/sensortoolkit2/docs/api/ray#filter) * [`IgnoreTriggerColliders`](https://micosmo.com/sensortoolkit2/docs/api/ray#ignoretriggercolliders) * [`MinimumSlopeAngle`](https://micosmo.com/sensortoolkit2/docs/api/ray#minimumslopeangle) * [`SlopeUpDirection`](https://micosmo.com/sensortoolkit2/docs/api/ray#slopeupdirection) * [`PulseMode`](https://micosmo.com/sensortoolkit2/docs/api/ray#pulsemode) * [`PulseInterval`](https://micosmo.com/sensortoolkit2/docs/api/ray#pulseinterval) * [`IsObstructed`](https://micosmo.com/sensortoolkit2/docs/api/ray#isobstructed) * [Events](https://micosmo.com/sensortoolkit2/docs/api/ray#events) * [`OnObstruction`](https://micosmo.com/sensortoolkit2/docs/api/ray#onobstruction) * [`OnClear`](https://micosmo.com/sensortoolkit2/docs/api/ray#onclear) * [Methods](https://micosmo.com/sensortoolkit2/docs/api/ray#methods) * [`GetDetectionRayHit(gameObject)`](https://micosmo.com/sensortoolkit2/docs/api/ray#getdetectionrayhitgameobject) * [`GetObstructionRayHit()`](https://micosmo.com/sensortoolkit2/docs/api/ray#getobstructionrayhit) --- # LOSSensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/los#) On this page Detects objects that are within line of sight. Subclass of [`Sensor`](https://micosmo.com/sensortoolkit2/docs/api/sensor) . Properties[​](https://micosmo.com/sensortoolkit2/docs/api/los#properties "Direct link to heading") --------------------------------------------------------------------------------------------------- ### `InputSensor`[​](https://micosmo.com/sensortoolkit2/docs/api/los#inputsensor "Direct link to heading") A [`Sensor`](https://micosmo.com/sensortoolkit2/docs/api/sensor) whose _Signals_ will be tested for line of sight. See [manual page](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#input-sensor) . ### `PulseMode`[​](https://micosmo.com/sensortoolkit2/docs/api/los#pulsemode "Direct link to heading") One of `EachFrame`, `FixedInterval` or `Manual`. ### `PulseInterval`[​](https://micosmo.com/sensortoolkit2/docs/api/los#pulseinterval "Direct link to heading") If `PulseMode` is set to `FixedInterval`, this is the time in seconds between each pulse. ### `BlocksLineOfSight`[​](https://micosmo.com/sensortoolkit2/docs/api/los#blockslineofsight "Direct link to heading") Layermask for which physics layers block line of sight rays. ### `IgnoreTriggerColliders`[​](https://micosmo.com/sensortoolkit2/docs/api/los#ignoretriggercolliders "Direct link to heading") The line of sight will not be blocked by _Trigger Colliders_ when this is true. ### `TestLOSTargetsOnly`[​](https://micosmo.com/sensortoolkit2/docs/api/los#testlostargetsonly "Direct link to heading") If this is true the sensor will only attempt line of sight tests on objects that have a `LOSTargets` component. See [manual](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#input-sensor) . ### `NumberOfRays`[​](https://micosmo.com/sensortoolkit2/docs/api/los#numberofrays "Direct link to heading") The number of randomly generated raycast targets to test on each object. Does nothing if that object has a `LOSTargets` component. ### `MinimumVisibility`[​](https://micosmo.com/sensortoolkit2/docs/api/los#minimumvisibility "Direct link to heading") The ratio of unobstructed raycasts must exceed this value for the object to be _detected_ by this sensor. ### `LimitDistance`[​](https://micosmo.com/sensortoolkit2/docs/api/los#limitdistance "Direct link to heading") Enables the [_Distance Limits_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#distance-limits) feature when this is true. ### `MaxDistance`[​](https://micosmo.com/sensortoolkit2/docs/api/los#maxdistance "Direct link to heading") When `LimitDistance` is `true` an object must be within this distance for it to be detected. ### `VisibilityByDistance`[​](https://micosmo.com/sensortoolkit2/docs/api/los#visibilitybydistance "Direct link to heading") A struct specifying how visibility is scaled as a function of distance. Choices are _Step_, _Linear Decay_ or a _Curve_. ### `LimitViewAngle`[​](https://micosmo.com/sensortoolkit2/docs/api/los#limitviewangle "Direct link to heading") Enables the [_Angle Limits_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#angle-limits) feature when this is true. ### `MaxHorizAngle`[​](https://micosmo.com/sensortoolkit2/docs/api/los#maxhorizangle "Direct link to heading") When `LimitViewAngle` is `true` an object must be within this horizontal view angle to be detected. ### `VisibilityByHorizAngle`[​](https://micosmo.com/sensortoolkit2/docs/api/los#visibilitybyhorizangle "Direct link to heading") A struct specifying how visibility is scaled as a function of horizontal view angle. Choices are _Step_, _Linear Decay_ or a _Curve_. ### `MaxVertAngle`[​](https://micosmo.com/sensortoolkit2/docs/api/los#maxvertangle "Direct link to heading") When `LimitViewAngle` is `true` an object must be within this vertical view angle to be detected. ### `VisibilityByVertAngle`[​](https://micosmo.com/sensortoolkit2/docs/api/los#visibilitybyvertangle "Direct link to heading") A struct specifying how visibility is scaled as a function of vertical view angle. Choices are _Step_, _Linear Decay_ or a _Curve_. Methods[​](https://micosmo.com/sensortoolkit2/docs/api/los#methods "Direct link to heading") --------------------------------------------------------------------------------------------- ### `GetResult(forObject)`[​](https://micosmo.com/sensortoolkit2/docs/api/los#getresultforobject "Direct link to heading") `ILOSResult GetResult(GameObject forObject)` Returns a data-object with details about the line of sight test for a given `GameObject`. The `ILOSResult` instances are cached by the sensor and reused each time it pulses. Don't hold onto this reference for long, it will be invalid after the next pulse. ### `GetAllResults()`[​](https://micosmo.com/sensortoolkit2/docs/api/los#getallresults "Direct link to heading") `List GetAllResults()` Returns a list of `ILOSResult` data-objects with line of sight results for all of the objects tested. ### `TestSignal(inputSignal)`[​](https://micosmo.com/sensortoolkit2/docs/api/los#testsignalinputsignal "Direct link to heading") `ILOSResult TestSignal(Signal inputSignal)` Immediately test line of sight for a given signal and return the results. This gives you full control to test line of sight when ever you need. Just keep in mind that the `ILOSResult` is stored until the next _Pulse_ and then returned to a cache. var player = GameObject.FindWithTag("player");var playerShape = new Bounds(new Vector3(0f, 1f, 0f), new Vector3(.3f, 2f, .3f));var losSensor = GetComponent();var losResult = losSensor.TestSignal(new Signal(player, 1f, playerShape));if (losResult.IsVisible) { Debug.Log("Player is detected with a visibility of " + losResult.Visibility);} Copy * [Properties](https://micosmo.com/sensortoolkit2/docs/api/los#properties) * [`InputSensor`](https://micosmo.com/sensortoolkit2/docs/api/los#inputsensor) * [`PulseMode`](https://micosmo.com/sensortoolkit2/docs/api/los#pulsemode) * [`PulseInterval`](https://micosmo.com/sensortoolkit2/docs/api/los#pulseinterval) * [`BlocksLineOfSight`](https://micosmo.com/sensortoolkit2/docs/api/los#blockslineofsight) * [`IgnoreTriggerColliders`](https://micosmo.com/sensortoolkit2/docs/api/los#ignoretriggercolliders) * [`TestLOSTargetsOnly`](https://micosmo.com/sensortoolkit2/docs/api/los#testlostargetsonly) * [`NumberOfRays`](https://micosmo.com/sensortoolkit2/docs/api/los#numberofrays) * [`MinimumVisibility`](https://micosmo.com/sensortoolkit2/docs/api/los#minimumvisibility) * [`LimitDistance`](https://micosmo.com/sensortoolkit2/docs/api/los#limitdistance) * [`MaxDistance`](https://micosmo.com/sensortoolkit2/docs/api/los#maxdistance) * [`VisibilityByDistance`](https://micosmo.com/sensortoolkit2/docs/api/los#visibilitybydistance) * [`LimitViewAngle`](https://micosmo.com/sensortoolkit2/docs/api/los#limitviewangle) * [`MaxHorizAngle`](https://micosmo.com/sensortoolkit2/docs/api/los#maxhorizangle) * [`VisibilityByHorizAngle`](https://micosmo.com/sensortoolkit2/docs/api/los#visibilitybyhorizangle) * [`MaxVertAngle`](https://micosmo.com/sensortoolkit2/docs/api/los#maxvertangle) * [`VisibilityByVertAngle`](https://micosmo.com/sensortoolkit2/docs/api/los#visibilitybyvertangle) * [Methods](https://micosmo.com/sensortoolkit2/docs/api/los#methods) * [`GetResult(forObject)`](https://micosmo.com/sensortoolkit2/docs/api/los#getresultforobject) * [`GetAllResults()`](https://micosmo.com/sensortoolkit2/docs/api/los#getallresults) * [`TestSignal(inputSignal)`](https://micosmo.com/sensortoolkit2/docs/api/los#testsignalinputsignal) --- # BooleanSensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/boolean#) On this page Combines the _Signals_ from a list of input _Sensors_. _Boolean Sensor_ is a subclass of [`Sensor`](https://micosmo.com/sensortoolkit2/docs/api/sensor) . Properties[​](https://micosmo.com/sensortoolkit2/docs/api/boolean#properties "Direct link to heading") ------------------------------------------------------------------------------------------------------- ### `InputSensors`[​](https://micosmo.com/sensortoolkit2/docs/api/boolean#inputsensors "Direct link to heading") The list of input sensors. Changing the list will cause this sensor to immediately re-evaluate it's output signals. ### `Operation`[​](https://micosmo.com/sensortoolkit2/docs/api/boolean#operation "Direct link to heading") One of `And` or `Or`. How this sensor merges signals from it's input sensors. See [manual](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#operation) . * [Properties](https://micosmo.com/sensortoolkit2/docs/api/boolean#properties) * [`InputSensors`](https://micosmo.com/sensortoolkit2/docs/api/boolean#inputsensors) * [`Operation`](https://micosmo.com/sensortoolkit2/docs/api/boolean#operation) --- # FOVCollider | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/fov#) On this page Generates a `Collider` shaped like a field-of-view cone. Properties[​](https://micosmo.com/sensortoolkit2/docs/api/fov#properties "Direct link to heading") --------------------------------------------------------------------------------------------------- ### `Length`[​](https://micosmo.com/sensortoolkit2/docs/api/fov#length "Direct link to heading") The length of the cone. ### `BaseSize`[​](https://micosmo.com/sensortoolkit2/docs/api/fov#basesize "Direct link to heading") The width of the cone at its base. This is a square shape. ### `FOVAngle`[​](https://micosmo.com/sensortoolkit2/docs/api/fov#fovangle "Direct link to heading") The field of view angle in degrees. ### `ElevationAngle`[​](https://micosmo.com/sensortoolkit2/docs/api/fov#elevationangle "Direct link to heading") The angle in degrees that the cone spans perpendicular to the field of view. ### `Resolution`[​](https://micosmo.com/sensortoolkit2/docs/api/fov#resolution "Direct link to heading") The subdivision level at the far end of the cone. Best to keep this as small as possible for performance reasons. ### `FOVMesh`[​](https://micosmo.com/sensortoolkit2/docs/api/fov#fovmesh "Direct link to heading") The `Mesh` that is generated by this component. Methods[​](https://micosmo.com/sensortoolkit2/docs/api/fov#methods "Direct link to heading") --------------------------------------------------------------------------------------------- ### `CreateCollider()`[​](https://micosmo.com/sensortoolkit2/docs/api/fov#createcollider "Direct link to heading") `void CreateCollider()` If you change any of these properties at runtime call this function after to generate a new collider. * [Properties](https://micosmo.com/sensortoolkit2/docs/api/fov#properties) * [`Length`](https://micosmo.com/sensortoolkit2/docs/api/fov#length) * [`BaseSize`](https://micosmo.com/sensortoolkit2/docs/api/fov#basesize) * [`FOVAngle`](https://micosmo.com/sensortoolkit2/docs/api/fov#fovangle) * [`ElevationAngle`](https://micosmo.com/sensortoolkit2/docs/api/fov#elevationangle) * [`Resolution`](https://micosmo.com/sensortoolkit2/docs/api/fov#resolution) * [`FOVMesh`](https://micosmo.com/sensortoolkit2/docs/api/fov#fovmesh) * [Methods](https://micosmo.com/sensortoolkit2/docs/api/fov#methods) * [`CreateCollider()`](https://micosmo.com/sensortoolkit2/docs/api/fov#createcollider) --- # NavMeshSensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/navmesh#) On this page A wrapper around the built-in navmesh functions. Properties[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#properties "Direct link to heading") ------------------------------------------------------------------------------------------------------- ### `Test`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#test "Direct link to heading") Which nav mesh function to use. Can be one of `Ray`, `Sample`, `ClosestEdge`. ### `Ray`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#ray "Direct link to heading") Parameters for the `Ray` test. These will be parameters for `NavMesh.Raycast`. ### `Sphere`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#sphere "Direct link to heading") Parameters for either `Sample` or `ClosestEdge` test. This is the search radius for these features. ### `AreaMask`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#areamask "Direct link to heading") Bitmask over the navmesh area ids. ### `PulseMode`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#pulsemode "Direct link to heading") One of `EachFrame`, `FixedInterval` or `Manual`. ### `PulseInterval`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#pulseinterval "Direct link to heading") If `PulseMode` is set to `FixedInterval`, this is the time in seconds between each pulse. ### `IsObstructed`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#isobstructed "Direct link to heading") Boolean specifying if the ray is currently obstructed. Events[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#events "Direct link to heading") ----------------------------------------------------------------------------------------------- ### `OnObstruction`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#onobstruction "Direct link to heading") `UnityEvent` invoked when the sensor is obstructed and was previously unobstructed. ### `OnClear`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#onclear "Direct link to heading") `UnityEvent` invoked when the sensor becomes unobstructed when it was previously obstructed. Methods[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#methods "Direct link to heading") ------------------------------------------------------------------------------------------------- ### `GetDetectionRayHit(gameObject)`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#getdetectionrayhitgameobject "Direct link to heading") `RayHit GetDetectionRayHit(GameObject detectedGameObject)` Will always return `RayHit.None` since this sensor doesn't detect objects. Use `GetObstructionRayHit()` instead. ### `GetObstructionRayHit()`[​](https://micosmo.com/sensortoolkit2/docs/api/navmesh#getobstructionrayhit "Direct link to heading") `RayHit GetObstruction()` Returns `RayHit` data for the current obstruction. * [Properties](https://micosmo.com/sensortoolkit2/docs/api/navmesh#properties) * [`Test`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#test) * [`Ray`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#ray) * [`Sphere`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#sphere) * [`AreaMask`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#areamask) * [`PulseMode`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#pulsemode) * [`PulseInterval`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#pulseinterval) * [`IsObstructed`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#isobstructed) * [Events](https://micosmo.com/sensortoolkit2/docs/api/navmesh#events) * [`OnObstruction`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#onobstruction) * [`OnClear`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#onclear) * [Methods](https://micosmo.com/sensortoolkit2/docs/api/navmesh#methods) * [`GetDetectionRayHit(gameObject)`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#getdetectionrayhitgameobject) * [`GetObstructionRayHit()`](https://micosmo.com/sensortoolkit2/docs/api/navmesh#getobstructionrayhit) --- # Sensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/sensor#) On this page The base class for the majority of sensors in the kit. It provides functionality for querying the detected `Signal`'s, and events for `OnDetection`, `OnLostDetection`. Properties[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#properties "Direct link to heading") ------------------------------------------------------------------------------------------------------ ### `Detections`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#detections "Direct link to heading") Enumerate through all the detected `GameObject`'s. Can be used in `foreach` and will not allocate garbage. ### `Signals`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#signals "Direct link to heading") Enumerate through all the detected `Signal`'s. Can be used in `foreach` and will not allocate garbage. ### `SignalProcessors`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#signalprocessors "Direct link to heading") Provides a way to apply custom transformation logic on the detected `Signal`'s. This is for advanced use-cases. Events[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#events "Direct link to heading") ---------------------------------------------------------------------------------------------- ### `OnDetected`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#ondetected "Direct link to heading") A `UnityEvent` invoked when a `GameObject` is detected (and previously undetected). ### `OnLostDetection`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#onlostdetection "Direct link to heading") A `UnityEvent` invoked when a `GameObject` that was previously detected is no longer detected. ### `OnSignalAdded`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#onsignaladded "Direct link to heading") An `Action` invoked when a `GameObject` is detected (and previously undetected). ### `OnSignalChanged`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#onsignalchanged "Direct link to heading") An `Action` invoked when a `Signal` for some detected `GameObject` was changed. This means either the `Shape` or `Strength` of the `Signal`. ### `OnSignalLost`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#onsignallost "Direct link to heading") An `Action` invoked when a `GameObject` that was previously detected is no longer detected. ### `OnPulsed`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#onpulsed "Direct link to heading") An `Action` invoked straight after the `Sensor` is `Pulse`'d. Methods[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#methods "Direct link to heading") ------------------------------------------------------------------------------------------------ ### `GetSignal(gameObject)`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#getsignalgameobject "Direct link to heading") `Signal GetSignal(GameObject go)` Returns the `Signal` associated with the detected `GameObject`. ### `TryGetSignal(gameObject, out signal)`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#trygetsignalgameobject-out-signal "Direct link to heading") `bool TryGetSignal(GameObject go, out Signal signal)` Safely retrieve the `Signal` associated with the detected `GameObject`. ### `IsDetected(gameObject)`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#isdetectedgameobject "Direct link to heading") `bool IsDetected(GameObject go)` Is the `GameObject` currently detected by the `Sensor`? ### `Pulse()`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#pulse "Direct link to heading") `void Pulse()` Causes the `Sensor` to perform it's _sensing_ routine, and determine a new list of detected `Signal`'s. Any detection events will fire at the end of this method. Query Methods[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#query-methods "Direct link to heading") ------------------------------------------------------------------------------------------------------------ There are many methods for retrieving the list of detections based on some parameters. They all follow a pattern so I won't list them all but rather show the main forms. The query functions can operate on one of: * **Signals** - Return a list of detected `Signal`'s. * **Detections** - Return a list of detected `GameObject`'s. * **DetectedComponents** - Return a list of `Component`'s owned by detected `Signal`'s. Furthermore each query function is overloaded and will optionally take a `Predicate` function or a `tag` which detections must match. ##### caution You can optionally provide your own `List` instance when you call a query method. If you omit it the `Sensor` will reuse the **same** `List` instance each time a query method is called. This makes them convenient to use without worrying about garbage generated, but it's important to be aware! ### `Get[...]`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#get "Direct link to heading") Return a list of detected `[...]` ### `Get[...]ByDistance`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#getbydistance "Direct link to heading") Same as above except the list is sorted by distance to the `Sensor`. ### `Get[...]ByDistanceToPoint`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#getbydistancetopoint "Direct link to heading") Same as above except the list is sorted by distance to some point. ### `GetNearest[...]`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#getnearest "Direct link to heading") Returns only the nearest `[...]` to the sensor. ### `GetNearest[...]ToPoint`[​](https://micosmo.com/sensortoolkit2/docs/api/sensor#getnearesttopoint "Direct link to heading") Returns only the nearest `[...]` to some point. * [Properties](https://micosmo.com/sensortoolkit2/docs/api/sensor#properties) * [`Detections`](https://micosmo.com/sensortoolkit2/docs/api/sensor#detections) * [`Signals`](https://micosmo.com/sensortoolkit2/docs/api/sensor#signals) * [`SignalProcessors`](https://micosmo.com/sensortoolkit2/docs/api/sensor#signalprocessors) * [Events](https://micosmo.com/sensortoolkit2/docs/api/sensor#events) * [`OnDetected`](https://micosmo.com/sensortoolkit2/docs/api/sensor#ondetected) * [`OnLostDetection`](https://micosmo.com/sensortoolkit2/docs/api/sensor#onlostdetection) * [`OnSignalAdded`](https://micosmo.com/sensortoolkit2/docs/api/sensor#onsignaladded) * [`OnSignalChanged`](https://micosmo.com/sensortoolkit2/docs/api/sensor#onsignalchanged) * [`OnSignalLost`](https://micosmo.com/sensortoolkit2/docs/api/sensor#onsignallost) * [`OnPulsed`](https://micosmo.com/sensortoolkit2/docs/api/sensor#onpulsed) * [Methods](https://micosmo.com/sensortoolkit2/docs/api/sensor#methods) * [`GetSignal(gameObject)`](https://micosmo.com/sensortoolkit2/docs/api/sensor#getsignalgameobject) * [`TryGetSignal(gameObject, out signal)`](https://micosmo.com/sensortoolkit2/docs/api/sensor#trygetsignalgameobject-out-signal) * [`IsDetected(gameObject)`](https://micosmo.com/sensortoolkit2/docs/api/sensor#isdetectedgameobject) * [`Pulse()`](https://micosmo.com/sensortoolkit2/docs/api/sensor#pulse) * [Query Methods](https://micosmo.com/sensortoolkit2/docs/api/sensor#query-methods) * [`Get[...]`](https://micosmo.com/sensortoolkit2/docs/api/sensor#get) * [`Get[...]ByDistance`](https://micosmo.com/sensortoolkit2/docs/api/sensor#getbydistance) * [`Get[...]ByDistanceToPoint`](https://micosmo.com/sensortoolkit2/docs/api/sensor#getbydistancetopoint) * [`GetNearest[...]`](https://micosmo.com/sensortoolkit2/docs/api/sensor#getnearest) * [`GetNearest[...]ToPoint`](https://micosmo.com/sensortoolkit2/docs/api/sensor#getnearesttopoint) --- # ArcSensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/arc#) On this page Detects objects intersected by an arc. Subclass of [`Sensor`](https://micosmo.com/sensortoolkit2/docs/api/sensor) . Properties[​](https://micosmo.com/sensortoolkit2/docs/api/arc#properties "Direct link to heading") --------------------------------------------------------------------------------------------------- ### `Parameterisation`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#parameterisation "Direct link to heading") One of `Bezier` or `Ballistic`. See [manual](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#parameterisation) . ### `Bezier`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#bezier "Direct link to heading") Values for the _Bezier Curve_ parameterisation. ### `Ballistic`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#ballistic "Direct link to heading") Values for the _Ballistic Curve_ parameterisation. ### `WorldSpace`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#worldspace "Direct link to heading") Is the curve parameterised in world space or local space. ### `DetectsOnLayers`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#detectsonlayers "Direct link to heading") A layer mask specifying which physics layers objects will be detected on. ### `ObstructedByLayers`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#obstructedbylayers "Direct link to heading") A layer mask specifying which physics layers objects will obstruct the ray on. ### `DetectionMode`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#detectionmode "Direct link to heading") * **`Colliders`** - sensor will detect the `Collider.gameObject`. * **`RigidBodies`** - sensor will detect the `Collider.attachedRigidBody.gameObject`. ### `Filter`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#filter "Direct link to heading") Configuration for filters including _Ignore List_ and _Tag Filter_. ### `IgnoreTriggerColliders`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#ignoretriggercolliders "Direct link to heading") Ignores all trigger colliders. Will not detect them or be obstructed by them. ### `PulseMode`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#pulsemode "Direct link to heading") One of `EachFrame`, `FixedInterval` or `Manual`. ### `PulseInterval`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#pulseinterval "Direct link to heading") If `PulseMode` is set to `FixedInterval`, this is the time in seconds between each pulse. ### `IsObstructed`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#isobstructed "Direct link to heading") Boolean specifying if the ray is currently obstructed. Events[​](https://micosmo.com/sensortoolkit2/docs/api/arc#events "Direct link to heading") ------------------------------------------------------------------------------------------- ### `OnObstruction`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#onobstruction "Direct link to heading") `UnityEvent` invoked when the sensor is obstructed and was previously unobstructed. ### `OnClear`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#onclear "Direct link to heading") `UnityEvent` invoked when the sensor becomes unobstructed when it was previously obstructed. Methods[​](https://micosmo.com/sensortoolkit2/docs/api/arc#methods "Direct link to heading") --------------------------------------------------------------------------------------------- ### `GetDetectionRayHit(gameObject)`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#getdetectionrayhitgameobject "Direct link to heading") `RayHit GetDetectionRayHit(GameObject detectedGameObject)` Returns the `RayHit` data for the given detected `GameObject`. ### `GetObstructionRayHit()`[​](https://micosmo.com/sensortoolkit2/docs/api/arc#getobstructionrayhit "Direct link to heading") `RayHit GetObstruction()` Returns `RayHit` data for the current obstruction. * [Properties](https://micosmo.com/sensortoolkit2/docs/api/arc#properties) * [`Parameterisation`](https://micosmo.com/sensortoolkit2/docs/api/arc#parameterisation) * [`Bezier`](https://micosmo.com/sensortoolkit2/docs/api/arc#bezier) * [`Ballistic`](https://micosmo.com/sensortoolkit2/docs/api/arc#ballistic) * [`WorldSpace`](https://micosmo.com/sensortoolkit2/docs/api/arc#worldspace) * [`DetectsOnLayers`](https://micosmo.com/sensortoolkit2/docs/api/arc#detectsonlayers) * [`ObstructedByLayers`](https://micosmo.com/sensortoolkit2/docs/api/arc#obstructedbylayers) * [`DetectionMode`](https://micosmo.com/sensortoolkit2/docs/api/arc#detectionmode) * [`Filter`](https://micosmo.com/sensortoolkit2/docs/api/arc#filter) * [`IgnoreTriggerColliders`](https://micosmo.com/sensortoolkit2/docs/api/arc#ignoretriggercolliders) * [`PulseMode`](https://micosmo.com/sensortoolkit2/docs/api/arc#pulsemode) * [`PulseInterval`](https://micosmo.com/sensortoolkit2/docs/api/arc#pulseinterval) * [`IsObstructed`](https://micosmo.com/sensortoolkit2/docs/api/arc#isobstructed) * [Events](https://micosmo.com/sensortoolkit2/docs/api/arc#events) * [`OnObstruction`](https://micosmo.com/sensortoolkit2/docs/api/arc#onobstruction) * [`OnClear`](https://micosmo.com/sensortoolkit2/docs/api/arc#onclear) * [Methods](https://micosmo.com/sensortoolkit2/docs/api/arc#methods) * [`GetDetectionRayHit(gameObject)`](https://micosmo.com/sensortoolkit2/docs/api/arc#getdetectionrayhitgameobject) * [`GetObstructionRayHit()`](https://micosmo.com/sensortoolkit2/docs/api/arc#getobstructionrayhit) --- # RangeSensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/range#) On this page Detects objects overlapping a volume. Subclass of [`Sensor`](https://micosmo.com/sensortoolkit2/docs/api/sensor) . Properties[​](https://micosmo.com/sensortoolkit2/docs/api/range#properties "Direct link to heading") ----------------------------------------------------------------------------------------------------- ### `Shape`[​](https://micosmo.com/sensortoolkit2/docs/api/range#shape "Direct link to heading") Can be one of `Sphere`, `Box` or `Capsule`, or 2D analogues for 2D version of the sensor. The shape of the detection volume. ### `Sphere`[​](https://micosmo.com/sensortoolkit2/docs/api/range#sphere "Direct link to heading") Configuration parameters for the `Sphere` shape. ### `Box`[​](https://micosmo.com/sensortoolkit2/docs/api/range#box "Direct link to heading") Configuration parameters for the `Box` shape. ### `Capsule`[​](https://micosmo.com/sensortoolkit2/docs/api/range#capsule "Direct link to heading") Configuration parameters for the `Capsule` shape. ### `DetectsOnLayers`[​](https://micosmo.com/sensortoolkit2/docs/api/range#detectsonlayers "Direct link to heading") A layer mask specifying which physics layers objects will be detected on. ### `DetectionMode`[​](https://micosmo.com/sensortoolkit2/docs/api/range#detectionmode "Direct link to heading") * **`Colliders`** - sensor will detect the `Collider.gameObject`. * **`RigidBodies`** - sensor will detect the `Collider.attachedRigidBody.gameObject`. ### `Filter`[​](https://micosmo.com/sensortoolkit2/docs/api/range#filter "Direct link to heading") Configuration for filters including _Ignore List_ and _Tag Filter_. ### `IgnoreTriggerColliders`[​](https://micosmo.com/sensortoolkit2/docs/api/range#ignoretriggercolliders "Direct link to heading") The sensor will not detect trigger colliders when this is set to true. ### `PulseMode`[​](https://micosmo.com/sensortoolkit2/docs/api/range#pulsemode "Direct link to heading") One of `EachFrame`, `FixedInterval` or `Manual`. ### `PulseInterval`[​](https://micosmo.com/sensortoolkit2/docs/api/range#pulseinterval "Direct link to heading") If `PulseMode` is set to `FixedInterval`, this is the time in seconds between each pulse. * [Properties](https://micosmo.com/sensortoolkit2/docs/api/range#properties) * [`Shape`](https://micosmo.com/sensortoolkit2/docs/api/range#shape) * [`Sphere`](https://micosmo.com/sensortoolkit2/docs/api/range#sphere) * [`Box`](https://micosmo.com/sensortoolkit2/docs/api/range#box) * [`Capsule`](https://micosmo.com/sensortoolkit2/docs/api/range#capsule) * [`DetectsOnLayers`](https://micosmo.com/sensortoolkit2/docs/api/range#detectsonlayers) * [`DetectionMode`](https://micosmo.com/sensortoolkit2/docs/api/range#detectionmode) * [`Filter`](https://micosmo.com/sensortoolkit2/docs/api/range#filter) * [`IgnoreTriggerColliders`](https://micosmo.com/sensortoolkit2/docs/api/range#ignoretriggercolliders) * [`PulseMode`](https://micosmo.com/sensortoolkit2/docs/api/range#pulsemode) * [`PulseInterval`](https://micosmo.com/sensortoolkit2/docs/api/range#pulseinterval) --- # Introduction | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/intro#) On this page _SensorToolkit_ is a collection of sensor components that _detect_ nearby objects and _sense_ the world around them. It's a powerful and convenient abstraction over basic sensing functions like: `Physics.RayCast`, `Physics.OverlapSphere` or `TriggerCollider`. Object detection code can get complicated, _SensorToolkit_ elegantly manages this complexity so you can focus on the fun stuff. The sensor components are modular and run independently. Simply add a sensor to a _GameObject_, configure it and you're done. Widgets and Custom inspectors help you debug and identify configuration problems quickly. Difference from v1[​](https://micosmo.com/sensortoolkit2/docs/intro#difference-from-v1 "Direct link to heading") ----------------------------------------------------------------------------------------------------------------- If you've used _SensorToolkit_ v1 then you should feel right at home. There's still the same familiar sensors, some new sensors have been added and the _Steering Rig_ is now the _Steering Sensor_. On the surface it may look similar but there are some significant differences. Some important changes are: * Sensors now give you more info about the objects they detect, such as their shape or visibility. A detected object and it's attributes is called a _Signal_. * There's a seperate sensor for line-of-sight testing, it's no longer an option on the _Trigger Sensor_ and _Range Sensor_. * Some sensors (such as the _LOS Sensor_) require another sensor as input. It reads the _Signals_ from the input, processes them, and generates its own _Signal_ list. * A bunch of new sensors added, and new features added to existing sensors. * The steering behaviour has been rewritten to use the _Context-Based Steering_ method. It's much improved over the _Steering Rig_ behaviour in v1. * [Difference from v1](https://micosmo.com/sensortoolkit2/docs/intro#difference-from-v1) --- # What's Included? | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/getting-started/whats-included#) On this page _SensorToolkit_ 2 will install itself into: `Assets/SensorToolkit/` inside you'll find a collection of sensor components and few directories. The sensors are standalone components, you can add them to your GameObjects' with the _Add Component_ menu. The important directories are described below: #### Examples/[​](https://micosmo.com/sensortoolkit2/docs/getting-started/whats-included#examples "Direct link to heading") In here you'll find some example scenes to learn how the sensors work. The _Fundamentals_ scene is a good starting place. It has a series of demo-stations, each designed to demonstrate the sensors in a concise way. The other scenes show how the sensors could be used in different game mechanics. #### Extras/[​](https://micosmo.com/sensortoolkit2/docs/getting-started/whats-included#extras "Direct link to heading") Some useful little scripts I'm providing as an extra. You can safely ignore anything in here, they're only used by the examples. I personally find them to be very useful so I elevated them out of the _Examples_ and into their own folder. #### Integrations/[​](https://micosmo.com/sensortoolkit2/docs/getting-started/whats-included#integrations "Direct link to heading") Has all the integration code for _SensorToolkit_ and other packages. Each integration will include a demo scene. You may need to import the integration by double-clicking the `.asset` file in its folder. #### src/[​](https://micosmo.com/sensortoolkit2/docs/getting-started/whats-included#src "Direct link to heading") Full source code is provided. --- # Upgrading from V1 | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/getting-started/upgrade-guide#) On this page _SensorToolkit 2_ is a standalone package from the original. Any work using the _v1_ assets will need to be done again with the _v2_ ones. To make migration easier it's possible to have both _v1_ and _v2_ installed simultaneously. You can phase out usage of _v1_ without breaking your project. Migration Guide[​](https://micosmo.com/sensortoolkit2/docs/getting-started/upgrade-guide#migration-guide "Direct link to heading") ----------------------------------------------------------------------------------------------------------------------------------- * First rename `Assets/SensorToolkit/` directory to `Assets/SensorToolkitV1` * Next import _SensorToolkit 2_ into your project, it will be put in `Assets/SensorToolkit` Now you will have the components from both versions available. Once you have phased out usage of _V1_ delete `Assets/SensorToolkitV1`. ### Namespaces[​](https://micosmo.com/sensortoolkit2/docs/getting-started/upgrade-guide#namespaces "Direct link to heading") _v2_ and _v1_ use different _C#_ namespaces: * `SensorToolkit` - used by _v1_ * `Micosmo.SensorToolkit` - used by _v2_ * [Migration Guide](https://micosmo.com/sensortoolkit2/docs/getting-started/upgrade-guide#migration-guide) * [Namespaces](https://micosmo.com/sensortoolkit2/docs/getting-started/upgrade-guide#namespaces) --- # 2D Components | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/2d#) _SensorToolkit_ works in both _2D_ and _3D_. Some of the sensors have a _2D_ specific version: * `RaySensor2D` * `RangeSensor2D` * `TriggerSensor2D` * `LOSSensor2D` * `ArcSensor2D` * `SteeringSensor2D` The remaining sensors already work in either modes. Most of the documentation and examples are focused on the _3D_ sensors. The _2D_ versions are practically identical with only minor differences here and there. The manual pages will point out where there are differences. --- # Signal Processor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/processor#) _Signal Processors_ provide a way to filter and change the _Signals_ produced by a _Sensor_. Every _Sensor_ has a list of _Signal Processors_ that are executed in sequence on its detections. A processor may change the _Strength_ or _Shape_ of a signal, map it to a different _GameObject_ or filter it from the detections completely. If you are using your own tag system and you want the sensors to filter on that, then _Signal Processors_ are an ideal way to implement it. ![](https://micosmo.com/sensortoolkit2/assets/images/signal-processor-91690747aa75f5990c7af7f5631013db.png) _The RangeSensor is using a MapStrengthByDistance processor. This will interpolate the signal strength of its detections by distance from the sensor. The processor has defined a minimum signal strength of 0.2, which is filtering out the furthest box from the detections list._ There's a handful of _SignalProcessors_ included in the toolkit, and it's straightforward to create your own by extending the base class `SignalProcessor`. Here is how you might write a processor that filters on a custom tag system. using System.Collections;using System.Collections.Generic;using UnityEngine;using Micosmo.SensorToolkit;// You should extend SignalProcessor, which itself extends MonoBehaviour.public class FilterExampleTagProcessor : SignalProcessor { public string[] AllowedTags; // Implement the Process function, the first parameter is the input signal, and the second // is the Sensor the signal originated from. The signal parameter is a 'ref', if you want // to change the signals properties then modify this parameter directly. public override bool Process(ref Signal signal, Sensor sensor) { var tag = signal.Object.GetComponent(); if (tag != null) { foreach (var allowedTag in AllowedTags) { if (tag.Tag == allowedTag) { return true; // Return true if you intend the signal to be detected } } } return false; // Return false if you intend the signal to be filtered out }} Copy I recommend examining the included _Signal Processors_ to better understand how to write your own. --- # FOV Collider | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/fov#) This component creates a cone-shaped collider that works well as a vision cone. It's made to be used along with the [_Trigger Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger) . ![](https://micosmo.com/sensortoolkit2/assets/images/fov-example-52d074933067b4eb492eea0f72a57a76.png) _An FOV Collider can be a character's vision cone_ --- # Quickstart Tutorial | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/getting-started/quickstart-tutorial#) On this page 5-minute guide[​](https://micosmo.com/sensortoolkit2/docs/getting-started/quickstart-tutorial#5-minute-guide "Direct link to heading") --------------------------------------------------------------------------------------------------------------------------------------- You can integrate _SensorToolkit_ into your game in no time at all. Let's say you have an _Enemy_ in your game, and you want the _Enemy_ to detect when the _Player_ is nearby and attack them. Here's what you can do: * Add a [_Range Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range) component to the _Enemy_. If your game is 2D then add the _Range Sensor 2D_ component instead. * Configure the _Range Sensor_. Set its size and shape, and make sure _Detects On Layers_ has the physics layer the _Player_ is on. You probably want to set _Detection Mode_ to _Rigid Bodies_ as well. * Click the 'Test' button. This will _Pulse_ the sensor in editor mode and show you everything it detects. Does the sensor detect the player? If the player wasn't in range then move it closer and click 'Test' again. ![](https://micosmo.com/sensortoolkit2/assets/images/test-button-ab5cd01a1c43982e40d21605887ddcf2.png) If the sensor can detect the _Player_ then all good you can move on. If not then edit the settings and try again. If you continue to have issues make sure the _Player_ has a _Collider_ and a _RigidBody_ component and that the correct physics layer is assigned on the sensor. ### Integration with scripts[​](https://micosmo.com/sensortoolkit2/docs/getting-started/quickstart-tutorial#integration-with-scripts "Direct link to heading") Let's say you're writing a _C#_ script called _EnemyBehaviour_. This script will be attached to the _Enemy_ and implement it's AI behaviour, if the player is in range then attack. The script would look something like this. using UnityEngine;using Micosmo.SensorToolkit;public class EnemyBehaviour : MonoBehaviour { Sensor sensor; void Awake() { sensor = GetComponent(); // RangeSensor extends the base class: Sensor } void Update() { var player = sensor.GetNearestDetection("Player"); // Assuming the player has the 'Player' tag assigned if (player != null) { // Attack behaviour here... } }} Copy ### Integration with Playmaker[​](https://micosmo.com/sensortoolkit2/docs/getting-started/quickstart-tutorial#integration-with-playmaker "Direct link to heading") If you're using Playmaker then you'll want to use the _Sensor Get Detections_ action. Configure it so it looks like the image below. Each frame the action checks for the nearest detection with the 'Player' tag. ![](https://micosmo.com/sensortoolkit2/assets/images/sensor-get-detections-24581c3871322a151675bf78e45a27b6.png) In a subsequent state you may want to check that the player is still detected by the sensor. Use the _Sensor Get Signal_ action for that. Next Steps[​](https://micosmo.com/sensortoolkit2/docs/getting-started/quickstart-tutorial#next-steps "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------- Using any of the sensors follows a similar process as above. Add the sensor you need, configure it, test it and integrate with your game logic. Have a look at the _Fundamentals.unity_ scene in `Assets/SensorToolkit/Examples/`, it has a sequence of hand-crafted demo-stations for each type of sensor. The other example scenes show how the sensors can be used to implement various mechanics. Most of the time you'll be using the [_Ray Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray) , [_Range Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range) , [_Trigger Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger) or [_Line of Sight Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los) . These are the best to learn first. * [5-minute guide](https://micosmo.com/sensortoolkit2/docs/getting-started/quickstart-tutorial#5-minute-guide) * [Integration with scripts](https://micosmo.com/sensortoolkit2/docs/getting-started/quickstart-tutorial#integration-with-scripts) * [Integration with Playmaker](https://micosmo.com/sensortoolkit2/docs/getting-started/quickstart-tutorial#integration-with-playmaker) * [Next Steps](https://micosmo.com/sensortoolkit2/docs/getting-started/quickstart-tutorial#next-steps) --- # Signal Proxy | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/proxy#) The _Signal Proxy_ component tells a _Sensor_ to detect a different object when the owner of the component is detected. It's useful for example if you have a character with a _RigidBody_ on each of its limbs. Normally this would cause a sensor to detect each limb individually, but you may want to detect the characters root instead. You could put this component on each limb and point it at the root. ![](https://micosmo.com/sensortoolkit2/assets/images/without-proxy-59813f546ecd7bef9a793bf2b665efd2.png) _This character has RigidBodies on each of its limbs. A sensor has detected each limb as a separate Signal_ ![](https://micosmo.com/sensortoolkit2/assets/images/with-proxy-93cb8e84d84e0da2c7ff2cf64093870d.png) _The same character but now each limb has a SignalProxy component that points to the character's root._ --- # AI Tree | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/integrations/aitree#) An integration package has been created by the developers of AI Tree. Please refer to [their docs](https://renownedgames.gitbook.io/ai-tree/integrations/sensor-toolkit-2) for instructions how to install it. --- # Behavior Designer | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#) On this page The integration for _Behavior Designer_ is located in `SensorToolkit/Integrations/Behavior Designer`. In there you'll find a file `behavior-designer-integration.asset`. Double-click it to extract the files. Make sure you already have _Behaviour Designer_ imported into your project or you will get compile errors. A unity scene called _demo_ will be extracted. Open it up to see a simple example of how to build behaviour trees that use the integration. ![](https://micosmo.com/sensortoolkit2/assets/images/example-tree-29cda6299ecef6e31478d39675be620a.png) _A portion of the behavior tree that will seek towards a detected object_ The integration includes some custom `Action`s and `Conditional`s. These will be found in the _Behavior Designer_ Tasks viewer under the _SensorToolkit_ category. Actions[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#actions "Direct link to heading") --------------------------------------------------------------------------------------------------------------------------- ### Get Detections[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#get-detections "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/get-detections-c393b7a226d8abe6f427b7fb12b24120.png) Queries the sensor for the GameObjects it detects. Returns success if at least one object is detected. Returns false otherwise. It's possible to restrict the query to objects with a specific tag. ### Get Signal[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#get-signal "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/get-signal-07f5b048f6a4ba3adf799fde2a8803da.png) Retrieve the `Signal` data for a GameObject. This will give you the objects visibility (Signal Strength) and its bounding box. Returns failure if the object isnt detected. ### Pulse[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#pulse "Direct link to heading") ![](data:image/png;base64,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) Manually pulses the sensor. ### Get Detection Ray Hit[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#get-detection-ray-hit "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/get-detection-ray-hit-12eccb8d10e5a811dc64cead65debad9.png) For a valid raycasting sensor this will retrieve the ray intersection details for a detected object. Works with the Ray Sensor, Arc Sensor and their 2D analogues. Returns failure if the object is not detected. ### Set Seek Target[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#set-seek-target "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/set-seek-target-a205a07dae499d60bd0f329eb2dac8d7.png) Sets the destination that a steering sensor should seek towards. The destination can be either a `GameObject` or a world-space `Vector3`. The _Target Distance_ can be increased to create a 'flee' behaviour. ### Set Strafe Target[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#set-strafe-target "Direct link to heading") ![](data:image/png;base64,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) If the Steering Sensor has built-in locomotion enabled this will control the strafing behaviour. The target is a direction or `GameObject` the agent should face while it seeks it's destination. Call this with no parameters to stop strafing. Conditionals[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#conditionals "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------------- ### Is Detected[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#is-detected "Direct link to heading") ![](data:image/png;base64,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) Returns success if the target object is detected by the sensor. Returns failure otherwise. ### Has Any Detection[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#has-any-detection "Direct link to heading") ![](data:image/png;base64,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) Returns success if the sensor has at least one detection. Returns failure otherwise. ### Is Obstructed[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#is-obstructed "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/is-obstructed-258ec932f5aece4df6a2eeaa95ae7799.png) For a valid raycasting sensor this will retrieve the ray intersection details where it's obstructed. Works with the Ray Sensor, Arc Sensor, NavMesh Sensor and their 2D analogues. Returns failure if there is no obstruction. ### Is Seeking[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#is-seeking "Direct link to heading") ![](data:image/png;base64,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) Returns success when the SteeringSensor is currently seeking towards a destination. Returns false if it's not seeking or has already reached its destination. * [Actions](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#actions) * [Get Detections](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#get-detections) * [Get Signal](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#get-signal) * [Pulse](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#pulse) * [Get Detection Ray Hit](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#get-detection-ray-hit) * [Set Seek Target](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#set-seek-target) * [Set Strafe Target](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#set-strafe-target) * [Conditionals](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#conditionals) * [Is Detected](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#is-detected) * [Has Any Detection](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#has-any-detection) * [Is Obstructed](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#is-obstructed) * [Is Seeking](https://micosmo.com/sensortoolkit2/docs/manual/integrations/behavior-designer#is-seeking) --- # Game Creator 2 | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/integrations/gamecreator2#) On this page The integration for _Game Creator 2_ is located in `SensorToolkit/Integrations/Game Creator 2`. In there you'll find a file `gamecreator2-integration.asset`. Double-click it to extract the files. Make sure you already have _Game Creator 2_ imported into your project or you will get compile errors. The integration includes many actions, conditions and triggers for the Game Creator visual scripting system. Find them all under the _SensorToolkit_ category. Open the _demo_ scene to see an example how to use the integration. Actions[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/gamecreator2#actions "Direct link to heading") ---------------------------------------------------------------------------------------------------------------------- * **Clear Sensor:** Clears the Sensor of all its detections. * **Get Detections:** Get all detected game objects of a sensor and store in a list. * **Get Line Of Sight Result:** Get detailed results of a line of sight test for the specified target. * **Get Nearest Detection:** Gets the nearest detected game object to the Sensor. * **Get Nearest Detection To Point:** Gets the nearest detected game object to the specified point. * **Get Signal:** Get the Signal data for the detected game object. * **Pulse Sensor:** Manually pulses the sensor. * **Set Pulse Interval:** Sets the interval at which the Sensor will pulse. The Sensor should be set to 'Fixed Interval' mode for this to work. * **Set Pulse Mode:** Sets the mode by which the sensor will pulse * **Seek Game Object:** Set the game object that the SteeringSensor should seek. * **Seek Position:** Set the position that the SteeringSensor should seek. * **Clear Seek Target:** Clears the Seek Target on the SteeringSensor so that it stops seeking. Conditions[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/gamecreator2#conditions "Direct link to heading") ---------------------------------------------------------------------------------------------------------------------------- * **Compare Visibility:** Returns true if the visibility of the target satisfies the comparison. * **Is Detected:** Returns true if the game object is detected by the Sensor. * **Is Obstructed:** Returns true if the RaySensor is obstructed. * **Is Seeking:** Returns true if the SteeringSensor is currently seeking. Triggers[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/gamecreator2#triggers "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------ * **On Clear:** Executed when the RaySensor is clear and was previously obstructed. * **On Obstruction:** Executes when the RaySensor is obstructed and was previously clear. * **On Detection:** Executes when the Sensor detects a new game object. * **On Detection Lost:** Executes when the Sensor loses detection of a game object. * **On Some Detection:** Executes when the Sensor detects a game object and previously detected nothing * **On No Detection:** Executes when the Sensor no longer detects any game objects. Property Accessors[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/gamecreator2#property-accessors "Direct link to heading") -------------------------------------------------------------------------------------------------------------------------------------------- * **Is Detected:** Returns true if the target is detected by the sensor. * **Is Ray Obstructed:** Returns true if the RaySensor is currently obstructed. * **Is Seeking:** Returns true if the SteeringSensor is currently seeking towards a target. * **Is Seek Target Reached:** Returns true if the SteeringSensor has reached its destination. * **Signal Strength:** Returns the signal strength for a detected game object on a Sensor. * **Ray Detection Normal:** Returns the hit normal direction for a game object detected by a RaySensor. * **Ray Obstruction Normal:** Returns the hit normal direction for a game object obstructiong the RaySensor. * **Steering Vector:** Returns the Steering Vector from the SteeringSensor. This points towards the seek target while avoiding nearby obstacles. * **Get Nearest Detection:** Returns the nearest detected game object to the Sensor. * **Get Nearest Detection To Point:** Returns the nearest detected game object to the specified point. * **Ray Obstruction Target:** Returns the game object that is obstructing a RaySensor. * **Ray Detection Position:** Returns the hit position for a game object detected by a RaySensor. * **Ray Obstruction Position:** Returns the hit position that is obstructing a RaySensor. * [Actions](https://micosmo.com/sensortoolkit2/docs/manual/integrations/gamecreator2#actions) * [Conditions](https://micosmo.com/sensortoolkit2/docs/manual/integrations/gamecreator2#conditions) * [Triggers](https://micosmo.com/sensortoolkit2/docs/manual/integrations/gamecreator2#triggers) * [Property Accessors](https://micosmo.com/sensortoolkit2/docs/manual/integrations/gamecreator2#property-accessors) --- # TriggerSensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/trigger#) On this page Detects objects that collider with a _Trigger Collider_. Subclass of [`Sensor`](https://micosmo.com/sensortoolkit2/docs/api/sensor) . Properties[​](https://micosmo.com/sensortoolkit2/docs/api/trigger#properties "Direct link to heading") ------------------------------------------------------------------------------------------------------- ### `DetectionMode`[​](https://micosmo.com/sensortoolkit2/docs/api/trigger#detectionmode "Direct link to heading") * **`Colliders`** - sensor will detect the `Collider.gameObject`. * **`RigidBodies`** - sensor will detect the `Collider.attachedRigidBody.gameObject`. ### `Filter`[​](https://micosmo.com/sensortoolkit2/docs/api/trigger#filter "Direct link to heading") Configuration for filters including _Ignore List_ and _Tag Filter_. ### `RunInSafeMode`[​](https://micosmo.com/sensortoolkit2/docs/api/trigger#runinsafemode "Direct link to heading") When set to true the sensor runs in [_Safe Mode_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#safe-mode) . * [Properties](https://micosmo.com/sensortoolkit2/docs/api/trigger#properties) * [`DetectionMode`](https://micosmo.com/sensortoolkit2/docs/api/trigger#detectionmode) * [`Filter`](https://micosmo.com/sensortoolkit2/docs/api/trigger#filter) * [`RunInSafeMode`](https://micosmo.com/sensortoolkit2/docs/api/trigger#runinsafemode) --- # SteeringSensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/steering#) On this page Responds to the detections from input sensors to implement local avoidance detection. Properties[​](https://micosmo.com/sensortoolkit2/docs/api/steering#properties "Direct link to heading") -------------------------------------------------------------------------------------------------------- ### `IsSpherical`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#isspherical "Direct link to heading") _Steering Vectors_ are 3D when this is `true` and they are planar when this is `false`. ### `Resolution`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#resolution "Direct link to heading") Determines the number of discrete buckets that directions around the sensor are boken up into. See [manual](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#shape) . ### `InterpolationSpeed`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#interpolationspeed "Direct link to heading") Speed that the sensor interpolates it's state. See [manual](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#interpolation-speed) . ### `Seek`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#seek "Direct link to heading") Configurations the _Seek_ target. ### `Interest`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#interest "Direct link to heading") Configurations for the _Interest_ behaviour. ### `Danger`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#danger "Direct link to heading") Configurations for the _Danger_ behaviour. ### `Velocity`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#velocity "Direct link to heading") Configurations for the _Velocity_ behaviour. ### `Decision`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#decision "Direct link to heading") Configurations for the _Decision_ behaviour. ### `PulseMode`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#pulsemode "Direct link to heading") One of `EachFrame`, `FixedInterval` or `Manual`. ### `PulseInterval`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#pulseinterval "Direct link to heading") If `PulseMode` is set to `FixedInterval`, this is the time in seconds between each pulse. ### `IsDestinationReached`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#isdestinationreached "Direct link to heading") Is `true` when we are within the desired range from the target seek position. ### `IsSeeking`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#isseeking "Direct link to heading") Is `true` when we have not yet reached the destination. ### `LocomotionMode`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#locomotionmode "Direct link to heading") See the [manual](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#locomotion-mode) . Enables the built-in locomotion if this is any value other then `None`. ### `Locomotion`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#locomotion "Direct link to heading") The configurations for the built-in locomotion behaviours. Methods[​](https://micosmo.com/sensortoolkit2/docs/api/steering#methods "Direct link to heading") -------------------------------------------------------------------------------------------------- ### `SeekTo(destination, distanceOffset)`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#seektodestination-distanceoffset "Direct link to heading") `void SeekTo(Transform destination, float distanceOffset = 0f)` `void SeekTo(Vector3 destination, float distanceOffset = 0f)` Helper functions for configuring the _Seek_ behaviour. Sets the _Seek Mode_ to `Position` and sets the destination to either a _Transform_ or _Vector3_. When `distanceOffset` is greater then 0 the agent will seek this distance away from the destination. The agent will not stop at the destination. ### `ArriveTo(destination, distanceOffset)`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#arrivetodestination-distanceoffset "Direct link to heading") `void ArriveTo(Transform destination, float distanceOffset = 0f)` `void ArriveTo(Vector3 destination, float distanceOffset = 0f)` Helper functions for configuring the _Seek_ behaviour. Same as `SeekTo` except the agent will stop at the destination. ### `SeekDirection(direction)`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#seekdirectiondirection "Direct link to heading") `void SeekDirection(Vector3 direction)` Helper function for configuring the _Seek_ behaviour. Sets the _Seek Mode_ to `Direction` and assigns the target direction. ### `Wander()`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#wander "Direct link to heading") `void Wander()` Helper function for configuring the _Seek_ behaviour. Sets the _Seek Mode_ to `Wander`. ### `Stop()`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#stop "Direct link to heading") `void Stop()` Helper function for configuring the _Seek_ behaviour. Sets the _Seek Mode_ to `Stop`. ### `GetSteeringVector()`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#getsteeringvector "Direct link to heading") `Vector3 GetSteeringVector()` Returns a velocity vector chosen by the sensor to be ideal. ### `GetSpeedCandidate(direction)`[​](https://micosmo.com/sensortoolkit2/docs/api/steering#getspeedcandidatedirection "Direct link to heading") `float GetSpeedCandidate(Vector3 direction)` For a given direction this will return a speed candidate calculated by the _Velocity_ behaviour. It chooses between the _lower_ and _upper_ speed candidates by whichever is closest to the _preferred speed_. * [Properties](https://micosmo.com/sensortoolkit2/docs/api/steering#properties) * [`IsSpherical`](https://micosmo.com/sensortoolkit2/docs/api/steering#isspherical) * [`Resolution`](https://micosmo.com/sensortoolkit2/docs/api/steering#resolution) * [`InterpolationSpeed`](https://micosmo.com/sensortoolkit2/docs/api/steering#interpolationspeed) * [`Seek`](https://micosmo.com/sensortoolkit2/docs/api/steering#seek) * [`Interest`](https://micosmo.com/sensortoolkit2/docs/api/steering#interest) * [`Danger`](https://micosmo.com/sensortoolkit2/docs/api/steering#danger) * [`Velocity`](https://micosmo.com/sensortoolkit2/docs/api/steering#velocity) * [`Decision`](https://micosmo.com/sensortoolkit2/docs/api/steering#decision) * [`PulseMode`](https://micosmo.com/sensortoolkit2/docs/api/steering#pulsemode) * [`PulseInterval`](https://micosmo.com/sensortoolkit2/docs/api/steering#pulseinterval) * [`IsDestinationReached`](https://micosmo.com/sensortoolkit2/docs/api/steering#isdestinationreached) * [`IsSeeking`](https://micosmo.com/sensortoolkit2/docs/api/steering#isseeking) * [`LocomotionMode`](https://micosmo.com/sensortoolkit2/docs/api/steering#locomotionmode) * [`Locomotion`](https://micosmo.com/sensortoolkit2/docs/api/steering#locomotion) * [Methods](https://micosmo.com/sensortoolkit2/docs/api/steering#methods) * [`SeekTo(destination, distanceOffset)`](https://micosmo.com/sensortoolkit2/docs/api/steering#seektodestination-distanceoffset) * [`ArriveTo(destination, distanceOffset)`](https://micosmo.com/sensortoolkit2/docs/api/steering#arrivetodestination-distanceoffset) * [`SeekDirection(direction)`](https://micosmo.com/sensortoolkit2/docs/api/steering#seekdirectiondirection) * [`Wander()`](https://micosmo.com/sensortoolkit2/docs/api/steering#wander) * [`Stop()`](https://micosmo.com/sensortoolkit2/docs/api/steering#stop) * [`GetSteeringVector()`](https://micosmo.com/sensortoolkit2/docs/api/steering#getsteeringvector) * [`GetSpeedCandidate(direction)`](https://micosmo.com/sensortoolkit2/docs/api/steering#getspeedcandidatedirection) --- # UserSignals | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/user-signals#) On this page A simple sensor that detects what you tell it to. Subclass of [`Sensor`](https://micosmo.com/sensortoolkit2/docs/api/sensor) . Properties[​](https://micosmo.com/sensortoolkit2/docs/api/user-signals#properties "Direct link to heading") ------------------------------------------------------------------------------------------------------------ ### `InputSignals`[​](https://micosmo.com/sensortoolkit2/docs/api/user-signals#inputsignals "Direct link to heading") A list of _Signals_ that the sensor should detect. This sensor fires any detection events immediately when this list is changed. * [Properties](https://micosmo.com/sensortoolkit2/docs/api/user-signals#properties) * [`InputSignals`](https://micosmo.com/sensortoolkit2/docs/api/user-signals#inputsignals) --- # Signal | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/api/signal#) On this page A small data-structure representing an object that is detected. Properties[​](https://micosmo.com/sensortoolkit2/docs/api/signal#properties "Direct link to heading") ------------------------------------------------------------------------------------------------------ ### `Object`[​](https://micosmo.com/sensortoolkit2/docs/api/signal#object "Direct link to heading") The `GameObject` that this signal is associated with. ### `Strength`[​](https://micosmo.com/sensortoolkit2/docs/api/signal#strength "Direct link to heading") The visibility of the signal. In the future this may be treated more abstractly, for example the [_Steering Sensor_](https://micosmo.com/sensortoolkit2/docs/api/steering) may prioritise avoiding signals with higher `Strength`. Right now it's just visibility generated by [_LOS Sensor_](https://micosmo.com/sensortoolkit2/docs/api/los) . All other sensors set it to _1_. ### `Shape`[​](https://micosmo.com/sensortoolkit2/docs/api/signal#shape "Direct link to heading") A `Bounds` that approximates the shape of the object. This is in local coordinates to the `Object`. ### `Bounds`[​](https://micosmo.com/sensortoolkit2/docs/api/signal#bounds "Direct link to heading") Get or set the `Shape` in world coordinates. Constructors[​](https://micosmo.com/sensortoolkit2/docs/api/signal#constructors "Direct link to heading") ---------------------------------------------------------------------------------------------------------- ### `Signal(obj, strength, shape)`[​](https://micosmo.com/sensortoolkit2/docs/api/signal#signalobj-strength-shape "Direct link to heading") `Signal(GameObject obj, float strength, Bounds shape)` Creates a `Signal` with specified _Object_, _Strength_ and _Shape_. ### `Signal(obj)`[​](https://micosmo.com/sensortoolkit2/docs/api/signal#signalobj "Direct link to heading") `Signal(GameObject obj)` Creates a `Signal` with specified _Object_. The _Strength_ will be _1_ and the _Shape_ will be a zero size `Bounds` centered at the _Objects_ position. Methods[​](https://micosmo.com/sensortoolkit2/docs/api/signal#methods "Direct link to heading") ------------------------------------------------------------------------------------------------ ### `Expand(collider)`[​](https://micosmo.com/sensortoolkit2/docs/api/signal#expandcollider "Direct link to heading") `void Expand(Collider c)` Expands this signals `Bounds` to encapsulate the the bounds of the collider. ### `Combine(signal)`[​](https://micosmo.com/sensortoolkit2/docs/api/signal#combinesignal "Direct link to heading") `void Combine(Signal signal)` This signal is combined with another. The resulting `Strength` is the maximum of either signal. The resulting `Shape` encapsulates the _Shapes_ of both. * [Properties](https://micosmo.com/sensortoolkit2/docs/api/signal#properties) * [`Object`](https://micosmo.com/sensortoolkit2/docs/api/signal#object) * [`Strength`](https://micosmo.com/sensortoolkit2/docs/api/signal#strength) * [`Shape`](https://micosmo.com/sensortoolkit2/docs/api/signal#shape) * [`Bounds`](https://micosmo.com/sensortoolkit2/docs/api/signal#bounds) * [Constructors](https://micosmo.com/sensortoolkit2/docs/api/signal#constructors) * [`Signal(obj, strength, shape)`](https://micosmo.com/sensortoolkit2/docs/api/signal#signalobj-strength-shape) * [`Signal(obj)`](https://micosmo.com/sensortoolkit2/docs/api/signal#signalobj) * [Methods](https://micosmo.com/sensortoolkit2/docs/api/signal#methods) * [`Expand(collider)`](https://micosmo.com/sensortoolkit2/docs/api/signal#expandcollider) * [`Combine(signal)`](https://micosmo.com/sensortoolkit2/docs/api/signal#combinesignal) --- # Fundamentals | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#) On this page Core Concepts[​](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#core-concepts "Direct link to heading") --------------------------------------------------------------------------------------------------------------------- All sensors share some concepts in common: * A `Sensor` is a _Component_ that has a list of _Signals_. * Each `Signal` stores one detected _GameObject_ and some data about the objects shape and visibility. * A _Sensor_ can `Pulse`, causing it to run its sensing routine and update its list of _Signals_. * Some sensors are _Compound_, they read the _Signals_ from another sensor and run additional detection logic. There are edge cases, but this is a good framework for understanding the kit. If a sensor deviates then it will be explained on its manual page. ### Sensor[​](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#sensor "Direct link to heading") Almost all of the sensors derive from a common base class `Sensor`. It provides a standard interface for querying what a `Sensor` can detect and hooking into its events. You can read its [API page here](https://micosmo.com/sensortoolkit2/docs/API/sensor) . Only the `NavMeshSensor` and `SteeringSensor` do not derive from `Sensor`. ### Signal[​](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#signal "Direct link to heading") A `Signal` is a small data structure that references a detected _GameObject_ and holds a bit of information about the detection. The data it holds is as follows: * **Object** - The _GameObject_ that is detected. * **Strength** - A value representing how visible the signal is. * **Shape** - A bounding box approximating the shape that the object appears to be. A sensor will have at most **one** `Signal` for any _GameObject_. ### Pulse[​](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#pulse "Direct link to heading") Most sensors have a `Pulse` action that runs its detection routines. A list of signals is generated and compared to the previous list. Events are fired for new detections and for lost detections. You can configure when a sensor will pulse by setting its `PulseMode`. The modes available are: * **Each Frame** - The sensor will pulse each frame in the _Update_ stage. * **Fixed Interval** - The sensor pulses at a regular time interval in seconds. This is recommended where possible for optimising performance. The intervals are staggered with a random offset so sensors with equal intervals are spread across frames. * **Manual** - The sensor will only pulse if you invoke its `Pulse()` method via script or PlayMaker. Scripting API[​](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#scripting-api "Direct link to heading") --------------------------------------------------------------------------------------------------------------------- All classes are in the `Micosmo.SensorToolkit` namespace. A simple script that reads a sensor might look like this: using UnityEngine;using Micosmo.SensorToolkit;public class AIBehaviour : MonoBehaviour { public Sensor sensor; void Update() { var pickup = sensor.GetNearestDetection("pickup"); if (pickup != null) { // Collect it... } }} Copy Of course it's also possible to subscribe to the `OnDetected` and `OnLostDetection` events instead so it's not necessary to check the sensor each frame. ### Garbage Collector Optimisation[​](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#garbage-collector-optimisation "Direct link to heading") Special care was taken to design SensorToolkit so that it never allocates _GC_. If you call a function that returns a `List` I will have implemented it so the **same** `List` instance is returned each time. The goal being that it's super-convenient to return a list of detections and iterate over them. List enemies = sensor.GetSignals("enemy"); // Get all signals with tag "enemy"List friends = sensor.GetSignals("friend"); // ⚠️ 'enemies' will be overwrittenenemies == friends; // TrueList items = sensor.GetSignalsByDistance("item"); // ⚠️ different methods will also overwrite the Listenemies == items; // TrueList coverLocations = coverSensor.GetSignalsByDistance(); // ✔️ no issue here. Each sensor allocates its own reusable list. Copy To fix this you can write: // An optional last parameter let's you provide your own instance of ListList enemies = sensor.GetSignals("enemy", new List());List friends = sensor.GetSignals("friend", new List());enemies == friends; // False Copy * [Core Concepts](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#core-concepts) * [Sensor](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#sensor) * [Signal](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#signal) * [Pulse](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#pulse) * [Scripting API](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#scripting-api) * [Garbage Collector Optimisation](https://micosmo.com/sensortoolkit2/docs/manual/fundamentals#garbage-collector-optimisation) --- # Playmaker | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#) On this page SensorToolkit includes a number of custom Playmaker actions that make it convenient to use in your _FSMs_. The actions are all under the _SensorToolkit_ category in the actions list. They're listed here roughly ordered by how often you'll need them. Generic Sensor Actions[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#generic-sensor-actions "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------------------------- ### Sensor Get Detections[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-detections "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/sensor-get-detections-a04e7a155539c00a68288232f662f390.png) Queries the sensor for the _GameObjects_ it detects. There's a handful of query types including: 'All' to get all detected objects and 'Nearest' to get only the nearest detected object by distance. The query can be fine-tuned to return objects with specific tags, or objects that have specific components. ### Sensor Get Signal[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-signal "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/sensor-get-signal-62b8ac1a75ab6acfdae178f45ade3b15.png) Retrieve the [`Signal`](https://micosmo.com/sensortoolkit2/docs/api/signal) data for a _GameObject_. This will give you the objects visibility (Signal Strength) and it's center point. Use this also if you want to check if a _GameObject_ is currently detected or not. ### Sensor Listen Detection Events[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-listen-detection-events "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/sensor-listen-detection-events-276d60268c8e35c872f8ca70af9003ac.png) Subscribe to a sensors _OnDetection_, _OnLostDetection_ events. ### Sensor Pulse[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-pulse "Direct link to heading") ![](data:image/png;base64,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) Manually pulses the sensor. ### Sensor Configure Pulse Routine[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-configure-pulse-routine "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/sensor-configure-pulse-routine-e977e61f07c25f3db7b60010e2f7b755.png) Configure how often a sensor should pulse. Raycasting Sensor Actions[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#raycasting-sensor-actions "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------------------------------- ### Sensor Get Detection Ray Hit[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-detection-ray-hit "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/sensor-get-detection-ray-hit-62a3415c0c943b62b6726841acf561db.png) For a valid raycasting sensor this will retrieve the ray intersection details for a detected object. Works with the _Ray Sensor_, _Arc Sensor_ and their _2D_ analogues. ### Sensor Get Obstruction Ray Hit[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-obstruction-ray-hit "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/sensor-get-obstruction-ray-hit-b2bfc9d13252ecdc0fd691caddbd8c6d.png) For a valid raycasting sensor this will retrieve the ray intersection details where it's obstructed. Works with the _Ray Sensor_, _Arc Sensor_, _NavMesh Sensor_ and their _2D_ analogues. Line of Sight Sensor Actions[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#line-of-sight-sensor-actions "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------------------------------------- ### Sensor Get Line Of Sight Result[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-line-of-sight-result "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/sensor-get-line-of-sight-result-259d074074d8e3cdb2717769a4416b5f.png) For a _LOS Sensor_ this will give more detailed results from the line-of-sight test performed on an object. You will rarely need this action. To know an objects visibility it's better to use the _'Sensor Get Signal'_ action and use the _'Store Strength'_ output. Steering Sensor Actions[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#steering-sensor-actions "Direct link to heading") --------------------------------------------------------------------------------------------------------------------------------------------------- ### Steering Sensor Seek[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#steering-sensor-seek "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/steering-sensor-seek-5970872d624022278936dedd5a44cae3.png) Sets the target position to be seeked by the _Steering Sensor_. When the _Target Distance_ is set to a large number it behaves like a Flee behaviour. If the built-in locomotion is enabled the sensor will start moving to the target. Otherwise you can store the steering vector and move towards it with your own locomotion system. ### Steering Sensor Configure[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#steering-sensor-configure "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/steering-sensor-configure-b828b94c6677457a528cfef434862e6e.png) Exposes some configuration settings on the _Steering Sensor_ that control its behaviour. ### Steering Sensor Strafe[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#steering-sensor-strafe "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/steering-sensor-strafe-b568f408b70c2b508e7e3a7544d4ab23.png) If the _Steering Sensor_ has built-in locomotion enabled this will control the strafing behaviour. The target is a direction or _GameObject_ the agent should face while it seeks it's destination. Other Actions[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#other-actions "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------- ### Set FOV Collider[​](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#set-fov-collider "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/set-fov-collider-db400ddf08c8076e5089f2b5d79781a8.png) Generate a new collider shape based off the new parameters. This rebuilds the collider's _Mesh_ so it's recommended not to call it each frame. * [Generic Sensor Actions](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#generic-sensor-actions) * [Sensor Get Detections](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-detections) * [Sensor Get Signal](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-signal) * [Sensor Listen Detection Events](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-listen-detection-events) * [Sensor Pulse](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-pulse) * [Sensor Configure Pulse Routine](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-configure-pulse-routine) * [Raycasting Sensor Actions](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#raycasting-sensor-actions) * [Sensor Get Detection Ray Hit](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-detection-ray-hit) * [Sensor Get Obstruction Ray Hit](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-obstruction-ray-hit) * [Line of Sight Sensor Actions](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#line-of-sight-sensor-actions) * [Sensor Get Line Of Sight Result](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#sensor-get-line-of-sight-result) * [Steering Sensor Actions](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#steering-sensor-actions) * [Steering Sensor Seek](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#steering-sensor-seek) * [Steering Sensor Configure](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#steering-sensor-configure) * [Steering Sensor Strafe](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#steering-sensor-strafe) * [Other Actions](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#other-actions) * [Set FOV Collider](https://micosmo.com/sensortoolkit2/docs/manual/integrations/playmaker#set-fov-collider) --- # Arc Sensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#) On this page The _Arc Sensor_ detects objects that intersect a curve. It works just like the [_Ray Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray) in that it detects all objects up to the first obstruction. The arc is broken up into line segments and a raycast is done on each. ![](https://micosmo.com/sensortoolkit2/assets/images/arc-example-9ea522c983fd88a9de0bcbcfd1af6809.png) _An Arc Sensor detects a platform that can be jumped to_ Output Signals[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#output-signals "Direct link to heading") ---------------------------------------------------------------------------------------------------------------------- * **`Object`** - `Collider.gameObject` or `Collider.attachedRigidBody.gameObject` depending on _Detection Mode_ * **`Strength`** - Set to 1 * **`Shape`** - Zero-size _Bounds_ centred at the point of intersection An obstruction is **not** represented by a `Signal`. Obstructions are not defined to be detected, although it is possible for the same `GameObject` to be detected and obstructing simultaneously. you can retrieve details about the intersection of the ray with each object. Access it with the `GetDetectionRayHit()` or `GetObstructionRayHit()` methods. Configuration[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#configuration "Direct link to heading") -------------------------------------------------------------------------------------------------------------------- ### Parameterisation[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#parameterisation "Direct link to heading") How the arc is parameterised. Two choices are available: * _Bezier_ - A quadratic bezier curve defined by three points in local space. * _Ballistic_ - The arc of a projectile with constant velocity and acceleration over some amount of time. ### Segments[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#segments "Direct link to heading") The number of straight line segments the arc is broken into. The sensor does a raycast over each segment so it's best to keep the number as low as possible. The segments have variable length to fit the curve more closely. ### Layers[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#layers "Direct link to heading") See [_Ray Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#layers) ### Filters[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#filters "Direct link to heading") See [_Ray Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#filters) Optimisation Considerations[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#optimisation-considerations "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------------------------ See [_Ray Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#optimisation-considerations) API[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#api "Direct link to heading") ------------------------------------------------------------------------------------------------ [API page](https://micosmo.com/sensortoolkit2/docs/api/arc) * [Output Signals](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#output-signals) * [Configuration](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#configuration) * [Parameterisation](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#parameterisation) * [Segments](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#segments) * [Layers](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#layers) * [Filters](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#filters) * [Optimisation Considerations](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#optimisation-considerations) * [API](https://micosmo.com/sensortoolkit2/docs/manual/sensors/arc#api) --- # Range Sensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#) On this page The _Range Sensor_ detects objects that are inside its detection volume. It uses the family of _Overlap_ functions inside `Physics` or `Physics2D`. A detected object will have one or more `Collider` that overlaps the detection volume. ![](https://micosmo.com/sensortoolkit2/assets/images/range-example-6ddfb35f8df0f017e2c3c6ed2639da8f.png) _A Range Sensor detects nearby enemy ships_ Output Signals[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#output-signals "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------ * **`Object`** - `Collider.gameObject` or `Collider.attachedRigidBody.gameObject` depending on _Detection Mode_ * **`Strength`** - Set to 1 * **`Shape`** - The _Bounds_ encapsulates all the _Collider's_ associated to the _Signal_. Each `Signal` may have been generated by multiple _Colliders_. This will happen when a `GameObject` has multiple `Collider` components. Also when the sensor is in _Rigid Bodies_ mode there may be many _Colliders_ that are children to a `RigidBody`. The signals shape encapsulates the _Bounds_ of all the _Colliders_. Configuration[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#configuration "Direct link to heading") ---------------------------------------------------------------------------------------------------------------------- ### Shape[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#shape "Direct link to heading") There are several shapes to choose from. The 3D sensor has: _Sphere_, _Box_ and _Capsule_. The 2D sensor has 2D equivalents. The shape you choose determines the underlying `Physics` function called. For example the _Sphere_ shape will result in `Physics.OverlapSphereNonAlloc` and the _Cube_ shape will result in `Physics.OverlapBoxNonAlloc`. ### Layers[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#layers "Direct link to heading") The _Detects On Layers_ property is a layermask specifying what physics layers the sensor will detect _Colliders_ on. ### Filters[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#filters "Direct link to heading") Any `GameObject` in the _Ignore List_ will not be detected by the sensor. If the _Tag Filter_ is enabled then a `GameObject` must have one of the specified tags for it to be detected. API[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#api "Direct link to heading") -------------------------------------------------------------------------------------------------- [API page](https://micosmo.com/sensortoolkit2/docs/api/range) * [Output Signals](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#output-signals) * [Configuration](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#configuration) * [Shape](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#shape) * [Layers](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#layers) * [Filters](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#filters) * [API](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range#api) --- # Trigger Sensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#) On this page The _Trigger Sensor_ detects objects that intersect a _Trigger Collider_. It works by listening for the events `OnTriggerEnter` and `OnTriggerExit`. The sensor has a similar role as the [_Range Sensor_](https://micosmo.com/sensortoolkit2/docs/manual/sensors/range) , with some unique advantages. The downside is that its more difficult to configure. There are some subtle complexities to _Trigger Colliders_ in Unity that must be considered when using this sensor. ![](https://micosmo.com/sensortoolkit2/assets/images/trigger-example-9535b1852675b99f4bd7effacbda1cf9.png) _A Trigger Sensor listens for collision events on a Trigger Collider. Any colliding objects are detected_ Background Knowledge[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#background-knowledge "Direct link to heading") -------------------------------------------------------------------------------------------------------------------------------------- It's recommended to have an understanding of _Trigger Colliders_ and _Collision Detection_ in Unity. This [page](https://docs.unity3d.com/Manual/CollidersOverview.html) of the Unity manual is a good starting point. The _Collision action matrix_ tables at the bottom of that page are especially important to understand. It show's why _Trigger Sensors_ often need to have _Kinematic Rigid Bodies_ attached. The _Trigger Sensor_ is listening for collision detection events. When the `OnTriggerEnter` event is received then something is detected. When the `OnTriggerExit` event is received then a detection is lost. ##### info The sensor will display warnings for common configuration issues. For example if it sees that you'll need a _Kinematic RigidBody_ added in order for the above events to be received then it will tell you. Output Signals[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#output-signals "Direct link to heading") -------------------------------------------------------------------------------------------------------------------------- * **`Object`** - `Collider.gameObject` or `Collider.attachedRigidBody.gameObject` depending on _Detection Mode_ * **`Strength`** - Set to 1 * **`Shape`** - The _Bounds_ encapsulates all the _Colliders_ associated to the _Signal_. The _Trigger Sensor_ does not need to be pulsed. It's updated immediately when it receives `OnTriggerEnter` or `OnTriggerExit` events. It's not possible to test this sensor in edit mode. Configuration[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#configuration "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------ ### Layers[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#layers "Direct link to heading") There is no property on the sensor to configure the physics layers it detects on. Instead you must configure Unity's physics collision matrix in the project settings. The sensor is not opinionated how you configure your layers, and youre free to configure them how you want. In the end all that's important for the sensor is that it recieves those `OnTriggerEnter` and `OnTriggerExit` events. My recommended configuration is to create a physics layer called _sensors_ and put your _Trigger Sensors_ on that. In the collision matrix you can then control exactly which layers they detect. Also make sure the _sensors_ layer doesn't collide with itself, you probably don't want two _Trigger Sensors_ detecting each other. ![](data:image/png;base64,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) _'Sensors' is a dedicated physics layer for Trigger Sensors that will detect objects on 'Player' and 'Enemy' layers_ ### Filters[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#filters "Direct link to heading") Any `GameObject` in the _Ignore List_ will not be detected by the sensor. If the _Tag Filter_ is enabled then a `GameObject` must have one of the specified tags for it to be detected. ### Safe Mode[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#safe-mode "Direct link to heading") When you enable _Safe Mode_ the sensor will add a helper component that protects against some quirks in Unity where `OnTriggerExit` events are not triggered. This will happen when a detected object is deactivated, moved away from the sensor and then reactivated. The `OnTriggerExit` event is not triggered by deactivated _GameObjects_ and the _Trigger Sensor_ will still show that it's detected. Often this is a problem when using a _Pooling_ system, such as in the following example scenario: * An object named _SpaceShip_ is detected by the sensor. * The _SpaceShip_ was destroyed, so it's `GameObject` is disabled and returned to the pool. * The _SpaceShip_ is spawned somewhere else in the level, it's moved there and enabled. The sensor still thinks it's detected, even though it could be far away. In _Safe Mode_ the sensor will additionally check that detected objects send `OnTriggerStay` events. This will identify objects that are out of detection range but failed to send an `OnTriggerExit`. ##### info You can solve this issue without enabling _Safe Mode_. Just before you deactivate the object set it's position far from any sensor, eg: `object.transform.position = new Vector3(10000, 10000, 10000);`, and `OnTriggerExit` will be sent. This is the best solution but obviously it's a bit of a hassle so _Safe Mode_ is available as an alternative. ##### warning It may take a couple of in-game frames before _Safe Mode_ notices an object is not detected. This is because `OnTriggerStay` is fired during the physics update, which often occurs less frequently then regular updates. ![](https://micosmo.com/sensortoolkit2/assets/images/safe-mode-ce454853abc3b4bf4a8c3a1a3a3ebfa8.png) _Safe Mode is enabled so a helper component checks for invalid detections_ Performance Considerations[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#performance-considerations "Direct link to heading") -------------------------------------------------------------------------------------------------------------------------------------------------- The sensor does not implement `Update`, `LateUpdate` or `FixedUpdate` so there is no overhead to update them each frame. The only overhead is on Unity's physics system to calculate collisions between the _Trigger Colliders_ with other _Colliders_. Generally this is highly optimised, especially if the sensor is not moving. The sensor has good performance scalability if you need a large number of static trigger zones. _Safe Mode_ does need to update each frame, so there is an increased overhead per-sensor if it's enabled. API[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#api "Direct link to heading") ---------------------------------------------------------------------------------------------------- [API page](https://micosmo.com/sensortoolkit2/docs/api/trigger) * [Background Knowledge](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#background-knowledge) * [Output Signals](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#output-signals) * [Configuration](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#configuration) * [Layers](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#layers) * [Filters](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#filters) * [Safe Mode](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#safe-mode) * [Performance Considerations](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#performance-considerations) * [API](https://micosmo.com/sensortoolkit2/docs/manual/sensors/trigger#api) --- # Line of Sight Sensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#) On this page The _LOS Sensor_ detects objects that have a visibility percentage above some threshold. It determines visibility by casting rays at the object and calculating the ratio that are obstructed. It is a _Compound Sensor_, meaning it requires another sensor as input. The _Signals_ from the input sensor are each tested for line of sight. ![](https://micosmo.com/sensortoolkit2/assets/images/los-example-a4d5551182c4bfac7c5ff86b14cfe5b6.png) _The LOS sensor determines the soldier has a visibility of 0% and therefore not detected_ Output Signals[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#output-signals "Direct link to heading") ---------------------------------------------------------------------------------------------------------------------- * **`Object`** - Same as input _Signal_ * **`Strength`** - Visibility multiplied by the input _Signal's_ strength * **`Shape`** - Same as input _Signal_ The line of sight is calculated as soon as the input sensor detects a new `Signal`. It's updated each time the _LOS Sensor_ is pulsed. Test Points[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#test-points "Direct link to heading") ---------------------------------------------------------------------------------------------------------------- Rays are cast at a number of test points on each signal to determine visibility. By default the points are randomly generated within the _Shape_ of the signal. You can specify explicit test points by adding a `LOSTargets` component. If the sensor finds a `LOSTargets` component on the `Signal.Object` then it will use those test points instead. ![](https://micosmo.com/sensortoolkit2/assets/images/los-targets-3a6b0575e058573e3c2d99cc7134f0ba.png) _The yellow humanoid has a `LOSTargets` component specifying some of it's joints as test points_ Configuration[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#configuration "Direct link to heading") -------------------------------------------------------------------------------------------------------------------- ### Input Sensor[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#input-sensor "Direct link to heading") Can be any sensor deriving from [_Sensor_](https://micosmo.com/sensortoolkit2/docs/API/sensor) , such as the _Range Sensor_ or _Trigger Sensor_. It provides the _Signals_ that will be tested for line of sight. To be detected an object must first be detected by the input sensor and then additionally pass the line of sight test of this sensor. ### Raycasts[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#raycasts "Direct link to heading") The _Blocks Line Of Sight_ property configures which physics layers will block visibility. The number of raycasts performed when the sensor pulses is determined as follows: * If the object has a `LOSTargets` component it will cast a ray for each test point on that component. * Otherwise it will cast the number specified by the _Number Of Rays_ property. If you enable the _Test LOS Targets Only_ checkbox then the sensor will only work on objects with a `LOSTargets` component. ### Moving Average[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#moving-average "Direct link to heading") Enable this option to smooth the visibility scores over a number of pulses. It will reveal a new parameter called _Window Size_. The computed visibility of an object is its average visibility over a number of pulses equal to the _Window Size_. This is an effective way to eliminate sudden changes in visibility, even when the sensor tests with a single ray. ### Field of View Limits[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#field-of-view-limits "Direct link to heading") #### Distance Limits[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#distance-limits "Direct link to heading") When _Limit Distance_ is enabled visibility is scaled by distance to the sensor. The following properties become available: * _Max Distance_ - Objects must be within this distance to be detected. * _Visibility By Distance_ - Determines how visibility is scaled by distance to the sensor. The default is _Step_ meaning that visibilities are 0 when beyond the max range but are otherwise calculated normally. Other options include linear interpolation or custom curve. #### Angle Limits[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#angle-limits "Direct link to heading") When _Limit View Angle_ is enabled the visibility is scaled by angle to the sensor. The following properties become available: * _Max Horiz Angle_ - The max angle in the sensors horizontal field of view. * _max Vert Angle_ - The max angle in the sensors vertical field of view. * _Visibility By Horiz Angle_ - How is visibility scaled by a function of the horizontal angle. * _Visibility By Vert Angle_ - How is visibility scaled by a function of the vert angle. API[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#api "Direct link to heading") ------------------------------------------------------------------------------------------------ [API page](https://micosmo.com/sensortoolkit2/docs/api/los) * [Output Signals](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#output-signals) * [Test Points](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#test-points) * [Configuration](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#configuration) * [Input Sensor](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#input-sensor) * [Raycasts](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#raycasts) * [Moving Average](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#moving-average) * [Field of View Limits](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#field-of-view-limits) * [API](https://micosmo.com/sensortoolkit2/docs/manual/sensors/los#api) --- # Boolean Sensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#) On this page The _Boolean Sensor_ is another _Compound Sensor_ that combines the signals of it's input sensors. It merges the signals of each sensor via logical _And_ or logical _Or_. ![](https://micosmo.com/sensortoolkit2/assets/images/boolean-and-775763124a86749d7ba07e1e018623c4.png) _The Boolean Sensor in 'And' mode outputs signals if they are detected by all of the input sensors_ ![](https://micosmo.com/sensortoolkit2/assets/images/boolean-or-4094580cf57795ca1d61733ce1ddc999.png) _In 'Or' mode it outputs all signals detected by any of the input sensors_ Output Signals[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#output-signals "Direct link to heading") -------------------------------------------------------------------------------------------------------------------------- * **`Object`** - Same as input _Signal_ * **`Strength`** - Maximum of the input signals * **`Shape`** - Encapsulates the shape of the input signals If multiple input sensors detect the same object, their `Strength` and `Shape` are merged in the output signal. The _Boolean Sensor_ does not need to be pulsed. It will subscribe to the events of it's input sensors and will update immediately when any input signal is changed. Configuration[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#configuration "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------ ### Input Sensors[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#input-sensors "Direct link to heading") A list of sensors deriving from [_Sensor_](https://micosmo.com/sensortoolkit2/docs/API/sensor) . ### Operation[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#operation "Direct link to heading") How should this sensor combine the list of signals from it's input sensors: * **_And_** - An object is detected by this sensor when it's detected by each one of the input sensors. * **_Or_** - An object is detected by this sensor if any one of the input sensors detect it. * **_Exclusive Or_** - An object is detected when only one of the input sensors detect it. If two or more input sensors detect it then it won't be detected by the boolean sensor. API[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#api "Direct link to heading") ---------------------------------------------------------------------------------------------------- [API page](https://micosmo.com/sensortoolkit2/docs/api/boolean) * [Output Signals](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#output-signals) * [Configuration](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#configuration) * [Input Sensors](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#input-sensors) * [Operation](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#operation) * [API](https://micosmo.com/sensortoolkit2/docs/manual/sensors/boolean#api) --- # Ray Sensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#) On this page The _Ray Sensor_ detects objects intersected by a ray. It uses the family of raycast functions inside `Physics` or `Physics2D`. The sensor detects all objects along its path up until it hits an _Obstructing_ `Collider`. It will not detect objects beyond the obstruction. ![](https://micosmo.com/sensortoolkit2/assets/images/ray-example-17d6662c9500c5c6e2d80c14cc9e4d69.png) _A Ray Sensor detects the ground beneath the falling character_ Output Signals[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#output-signals "Direct link to heading") ---------------------------------------------------------------------------------------------------------------------- * **`Object`** - `Collider.gameObject` or `Collider.attachedRigidBody.gameObject` depending on _Detection Mode_ * **`Strength`** - Set to 1 * **`Shape`** - Zero-size _Bounds_ centred at the point of intersection An obstruction does not have a _Signal_ because obstructions are not detected. It is possible however for the same `GameObject` to be detected and obstructing simultaneously. you can retrieve details about the intersection of the ray with each object. Access it with the `GetDetectionRayHit()` or `GetObstructionRayHit()` methods. Configuration[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#configuration "Direct link to heading") -------------------------------------------------------------------------------------------------------------------- ### Shape[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#shape "Direct link to heading") There are several casting shapes to choose from. The 3D sensor has: _Ray_, _Sphere_, _Box_ and _Capsule_. The 2D sensor has 2D equivalents of these shapes. The shape you choose determines which physics function is called. For example _Ray_ would use `Physics.RayCast` and _Sphere_ would use `Physics.SphereCast`. ### Layers[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#layers "Direct link to heading") Both _Detects On Layers_ and _Obstructed By Layers_ are layer masks where you can choose one or more physics layers. The ray will intersect with a `Collider` if it's layer is specified in either mask, but the two cases work differently. * **Detects On Layers** - Will detect all intersected objects in one of these layers (depending on filter settings). * **Obstructed By Layers** - A `Collider` on this layer will obstruct the sensor if it's intersected. ![](https://micosmo.com/sensortoolkit2/assets/images/obstruction-example-d7ac851ccc21465318c391a39343e624.png) _The ray on top is unobstructed and detects all three characters. On the bottom the ray is obstructed by the wall, it will detect the character in front, but will not detect the characters behind_ ### Filters[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#filters "Direct link to heading") These properties let you filter which objects are detected by the sensor: #### Ignore List[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#ignore-list "Direct link to heading") Any `GameObject` in this list will not be detected by the sensor and will not obstruct the sensor. There is some nuance for how it filters obstructions. To decide if an obstructing `Collider` is ignored the following logic is used: * Ignore if `Collider.gameObject` is present in the ignore list. * Ignore if `Collider.attachedRigidBody.gameObject` is present in the ignore list. A `Signal` is ignored if its `Signal.Object` is present in the ignore list. #### Tag Filter[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#tag-filter "Direct link to heading") Activate tag filtering by clicking the _Enable Tag Filter_ option. Configure the filter by populating a list of allowed tags. For an object to be detected it's tag **must** be specified in this list. Obstructions aren't affected by the tag filter. #### Minimum Slope Angle[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#minimum-slope-angle "Direct link to heading") Filters detections and obstructions depending on the slope angle at the point of intersection. The slope angle is measured between the _Normal_ of the `RayCastHit` and the configured _Up_ direction. Optimisation Considerations[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#optimisation-considerations "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------------------------ Depending on the configuration the sensor will use either `Physics.RayCast` or `Physics.RayCastNonAlloc`. * **`Physics.RayCast`** - Calculates only the first intersection along the rays path. This has better performance. * **`Physics.RayCastNonAlloc`** - Calculates all intersections along the rays path. Not as good performance. The sensor is smart enough to use the better performance `Physics.RayCast` in certain configurations. * The _Detects On Layers_ mask is a subset of _Obstructed By Layers_. Anything the sensor can detect will also obstruct it. * _Tag Filter_ is disabled, _Ignore List_ is empty and _Minimum Slope Angle_ is set to 0. API[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#api "Direct link to heading") ------------------------------------------------------------------------------------------------ [API Page](https://micosmo.com/sensortoolkit2/docs/api/ray) * [Output Signals](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#output-signals) * [Configuration](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#configuration) * [Shape](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#shape) * [Layers](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#layers) * [Filters](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#filters) * [Optimisation Considerations](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#optimisation-considerations) * [API](https://micosmo.com/sensortoolkit2/docs/manual/sensors/ray#api) --- # NavMesh Sensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#) On this page The _NavMesh Sensor_ is a simple component that can detect certain features in a Unity `NavMesh`. It's a simple wrapper around the built-in navmesh functions: `NavMesh.Raycast`, `NavMesh.FindClosestEdge` and `NavMesh.SamplePosition`. It doesn't detect _Signals_ and therefore it's not derived from [`Sensor`](https://micosmo.com/sensortoolkit2/docs/API/sensor) . ![](https://micosmo.com/sensortoolkit2/assets/images/navmesh-example-961bdc3d727e18cc1e36b7e77d7a5359.png) _This Nav Mesh sensor is configured to find the nearest edge in the nav mesh_ Output[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#output "Direct link to heading") ---------------------------------------------------------------------------------------------------------- In any of it's modes the sensor will detect a single `RayHit`, which is a _Point_ and a _Normal_. Configuration[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#configuration "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------ ### Test[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#test "Direct link to heading") Specify which navmesh function to use: * **_Ray_** - Will use `NavMesh.Raycast` * **_Sample_** - Will use `NavMesh.Sample` * **_Closest Edge_** - Will use `NavMesh.ClosestEdge` In all cases the resulting data can be retreived with the `GetObstructionRayHit()` method. ### Area Mask[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#area-mask "Direct link to heading") Specify the navmesh area mask to test on. API[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#api "Direct link to heading") ---------------------------------------------------------------------------------------------------- [API page](https://micosmo.com/sensortoolkit2/docs/api/navmesh) * [Output](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#output) * [Configuration](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#configuration) * [Test](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#test) * [Area Mask](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#area-mask) * [API](https://micosmo.com/sensortoolkit2/docs/manual/sensors/navmesh#api) --- # Steering Sensor | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#) On this page The _Steering Sensor_ is used to implement local steering behaviour for your game's agents. When it is pulsed it will produce a _Steering Vector_. This is a velocity vector that the agent should match so it can reach targets of interest, while avoiding danger and potential collisions. The sensor implements a combination of _Context Based Steering_ and _RVO_ (Reciprocal Velocity Obstacles). Following the _Context Based Steering_ method described [here](https://andrewfray.wordpress.com/2013/03/26/context-behaviours-know-how-to-share/) , the sensor models its surroundings in a handful of spherical grids and chooses the direction that maximises a utility function. Some of these grids store candidate velocities calculated by the RVO method, these are velocities that won't result in a collision within a defined time horizon. The other grids store directions of interest or danger. Taken together, these grids decide the best direction to travel in and also the speeds that won't cause a collision. The _Steering Sensor_ can operate in a spherical mode suitable for flying agents, or a 2D planar mode for ground-based agents. ![](https://micosmo.com/sensortoolkit2/assets/images/steering-example-eb13f73eefab1abc6be79e4d0009ee1c.png) _The Steering Sensor avoids the nearby asteroid while seeking the magenta spaceship_ Output[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#output "Direct link to heading") ----------------------------------------------------------------------------------------------------------- The _Steering Vector_ is accessible with the `GetSteeringVector()` method. This will be a velocity vector that can be passed to a locomotion system. If the built-in locomotion system is enabled then each frame the _Steering Vector_ will be passed to that. The candidate speed for a given direction can be accessed with the `GetSpeedCandidate(direction)` method. These will be calculated by the _Velocity_ behaviour. Directional Grids[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#directional-grids "Direct link to heading") --------------------------------------------------------------------------------------------------------------------------------- To determine a _Steering Vector_ the sensor first models its surroundings in a handful of _Directional Grids_. These are arrays of scalar values where each index is mapped to the surface of a circle or a sphere. ![](https://micosmo.com/sensortoolkit2/assets/images/directional-grid-6ab9104869eddbf28803528ce40cf1d5.png) _A low resolution directional grid with 4 cells on the circle. The cells are stored sequentially in memory such as on the right. Higher resolutions of grids would break the circle up into a larger number cells._ Each cell of the _Directional Grid_ stores a value that describes some property of the spherical region it contains. The meaning of this value depends on the context. An interest grid for example would store a value in each cell measuring how interesting it is in that direction. A danger grid would store a value in each cell measuring how dangerous it is in that direction. The _Steering Sensor_ has four sub-behaviours: `Interest`, `Danger`, `Velocity` and `Decision`. Each behaviour produces one or more _Directional Grids_. The grids hold all the information needed by the sensor to decide the best _Steering Vector_. You can access the computed contents of these grids at runtime as well if you need it. Steer Behaviours[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#steer-behaviours "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------- ### Seek[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#seek "Direct link to heading") Here you can choose a destination that the agent should reach. The behaviour doesn't have a grid of it's own, instead it adds values to the `Interest` grid. Therefore this is an extension of the `Interest` behaviour. There are a handful 'seek' modes available: * **_Position_** - Causes the agent to aim towards a target `Transform` or `Vector3` position. The `ArriveDistanceThreshold` and `StoppingDistance` properties are relevant to this mode. You can query if the sensor has reached the destination using `SteeringSensor.IsDestinationReached`. * **_Direction_** - Causes the agent to aim towards a `Vector3` direction in world space. * **_Wander_** - Disables the 'seek' behaviour so it makes no changes to the `Interest` grid. * **_Stop_** - Will cause the agent to stop in place, no matter what is in the `Interest` grid or any other grid. ##### info A _Flee_ behaviour is also possible. Set the seek mode to _Position_ and the _Distance Offset_ to a large number. The agent will seek a position offset this distance away from the target. ##### warning The sensor cannot plan a path through a complex level geometry, it's limited to only what it see's around it. For this you will need a pathfinding system to generate a path. This sensor can still be used to follow that path. ### Interest[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#interest "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/interest-d5c672564cbdccbb42f77df582ccc9a4.png) This behaviour constructs a directional grid that represents how 'interesting' a direction is. The greater the value in a particular direction, the stronger it will influence the agent to choose that direction. Interest values are linearly decayed from the angle to the target, which creates lobe shapes in the grid. Interest values are not additive when two or more targets are nearby, for each direction only the maximum interest is taken. * **_Stabilization Weight_** - This helps to avoid the agent changing direction erratically. An interest vector of this length will be applied to the forward direction of the agent. Encourages the agent to keep its current direction. * **_Local Forward Direction_** - The local direction that the stabilization weight is applied in. * **_Sensors_** - A list of sensor references that detect interest targets. For each detected signal of each sensor in the list, interest will be applied to the grid in it's direction. * **_Signal Processors_** - A list of [_Processors_](https://micosmo.com/sensortoolkit2/docs/manual/processor) that will be run additionally on each signal from the sensor list. This is useful to filter out certain detections from the interest grid, or to modify the magnitude of interest a detection will have. * **_Mapping Function_** - How to calculate the interest value for each detection. Possible values are _Radial Interpolation_ which calculates interest by distance, or _Signal Strength_ which uses `Signal.Strength` as the interest. * **_Radial Interpolation_** - Only relevant when _Mapping Function_ is _Radial Interpolation_. Interest is interpolated from 1 to 0 by distance to the sensor. This property lets you set the interpolation range. ### Danger[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#danger "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/danger-07aadf26f389d7c203572f2ab2e5e8d3.png) This behaviour constructs a directional grid that represents how 'dangerous' a direction is. It's effectively the opposite of the Interest behaviour. Danger in a particular direction will influence the agent to avoid that direction. Danger values are also linearly decayed from the angle to the target. Danger values are not additive when two or more targets are nearby, for each direction only the maximum danger is taken. * **_Sensors_** - A list of sensor references that detect dangerous targets. For each detected signal of each sensor in the list, danger will be applied to the grid in it's direction. * **_Signal Processors_** - A list of [_Processors_](https://micosmo.com/sensortoolkit2/docs/manual/processor) that will be run additionally on each signal from the sensor list. This is useful to filter out certain detections from the danger grid, or to modify the magnitude of danger a detection will have. * **_Mapping Function_** - How to calculate the danger value for each detection. Possible values are _Radial Interpolation_ which calculates interest by distance, or _Signal Strength_ which uses `Signal.Strength` as the interest. * **_Radial Interpolation_** - Only relevant when _Mapping Function_ is _Radial Interpolation_. Danger is interpolated from 1 to 0 by distance to the sensor. This property lets you set the interpolation range. ##### info The _Velocity_ behaviour works better for obstacle avoidance, because it will cause the agent to speed-up and slow-down to avoid a collision giving more realistic results. The Danger behaviour works better for avoiding targets that are dangerous, but not necessarily on a collision course. ### Velocity[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#velocity "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/velocity-4bd306b06fd27b612029c5c58df0f642.png) The Velocity behaviour calculates speed candidates over each direction in the grid. A speed candidate would avoid collisions with all nearby obstacles within a defined time window. The behaviour estimates the velocity of each obstacle by comparing their positions between sensor pulses. Speed candidates are calculated using the _Velocity Obstacles_ algorithm. * **_Preferred Speed_** - The speed that the agent should attempt to achieve if there are no obstacles. * **_Max Speed_** - The maximum speed the agent can travel. The agent can speed up to this speed in order to avoid obstacles. * **_Sensors_** - A list of sensors that detect velocity obstacles. Velocities are estimated for each detection by comparing their positions between pulses. * **_Signal Processors_** - A list of signal processors that will be applied to the detections on the input sensors. * **_Agent Radius_** - The radius of the agent used to predict potential collisions. * **_Time Horizon_** - The sensor searches for speed candidates that avoids collisions within this time window. * **_Samples Per Pulse_** - The number of potential speed candidates tested each time the sensor is pulsed. Speed candidates are searched for in a Unity Job. Velocity obstacles are modeled as a sphere of radius `Max(Signal.Bounds.extents)`. The sensor calculates two speed candidates for each direction in the grid: a _lower_ candidate and an _upper_ candidate. The _lower_ candidate is chosen such that `0 <= lower <= preferredSpeed`, and the _upper_ candidate is chosen so `preferedSpeed <= upper <= maxSpeed`. ##### info The speed candidates produced in the last pulse are stored on the sensor. They can be queried at runtime for a given direction using the sensor's API. ### Decision[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#decision "Direct link to heading") ![](https://micosmo.com/sensortoolkit2/assets/images/decision-34f5d8a96fdd1245e6c359ce6532963c.png) The decision behaviour takes grids of all the previous behaviours and produces an overall score for each direction. The _Steering Vector_ produced by the sensor will be pointing to the direction with the highest score. * **_Max Danger Threshold_** - Danger scores above this threshold will always repulse the agent no matter how much interest there is in that direction. * **_Preferred Velocity Influence_** - How much the agent should favour directions that let it travel near its preferred speed. When this is greater then 0 the Velocity behaviour will steer the agent around obstacles. * **_Interpolation Speed_** - The values in the decision grid are interpolated over time. When the sensor pulses a target decision grid is created, and the current decision grid is gradually changed to match the target. The speed that the change happens is controlled by this parameter. This is useful so the sensor can be pulsed on a fixed interval without erratic behaviour. Locomotion[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#locomotion "Direct link to heading") ------------------------------------------------------------------------------------------------------------------- The steering vector is useful if you already have a movement system for your agent. Each frame get the vector and set your movement system to move in it's direction. Alternatively you can use one of the built-in locomotion systems. There are simple implementations for flying and ground-based agents. ##### info The built-in locomotion system is very simple and not recommended outside basic use cases. In most cases you will want to use an external locomotion system and use the _Steering Sensor_ to only calculate _Steering Vectors_. ### Locomotion Mode[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#locomotion-mode "Direct link to heading") _None_ by default, meaning locomotion is disabled and the sensor will only produce steering vectors. Can be set to one of: * **_Rigid Body Flying_** - to control a flying `RigidBody`, either kinematic or by forces * **_Rigid Body Character_** - to control a ground-based `RigidBody`, either kinematic or by forces * **_Unity Character Controller_** - to control a `CharacterController` component The 2D version has only **_Rigid Body 2D_** which could work for a flying agent or a ground-based agent in a top-down game. If a locomotion mode is selected you will see some extra properties that control it's max speed and acceleration. API[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#api "Direct link to heading") ----------------------------------------------------------------------------------------------------- [API page](https://micosmo.com/sensortoolkit2/docs/api/steering) * [Output](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#output) * [Directional Grids](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#directional-grids) * [Steer Behaviours](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#steer-behaviours) * [Seek](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#seek) * [Interest](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#interest) * [Danger](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#danger) * [Velocity](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#velocity) * [Decision](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#decision) * [Locomotion](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#locomotion) * [Locomotion Mode](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#locomotion-mode) * [API](https://micosmo.com/sensortoolkit2/docs/manual/sensors/steering#api) --- # User Signals | SensorToolkit 2 [Skip to main content](https://micosmo.com/sensortoolkit2/docs/manual/sensors/user-signals#) On this page The _User Signals_ sensor detects whatever you tell it to. It gives you a way to control directly some other _Compound Sensors_. For example you can use it with the _Line Of Sight_ sensor to test visibility of specific objects. ![](https://micosmo.com/sensortoolkit2/assets/images/user-example-a623ea418293192080214c91e9883b31.png) _The User Signals is configured explicitely to detect the Sword, Vase and Crate_ Output Signals[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/user-signals#output-signals "Direct link to heading") ------------------------------------------------------------------------------------------------------------------------------- You specify exactly what the output signals are by setting them in the _Input Signals_ list. There is no need for this sensor to _Pulse_. API[​](https://micosmo.com/sensortoolkit2/docs/manual/sensors/user-signals#api "Direct link to heading") --------------------------------------------------------------------------------------------------------- [API page](https://micosmo.com/sensortoolkit2/docs/api/user-signals) * [Output Signals](https://micosmo.com/sensortoolkit2/docs/manual/sensors/user-signals#output-signals) * [API](https://micosmo.com/sensortoolkit2/docs/manual/sensors/user-signals#api) --- # 404 Not Found 404 Not Found ============= * Code: NoSuchKey * Message: The specified key does not exist. * Key: sensortoolkit2/docs/API/sensor * RequestId: 26TGASKWPB793SPJ * HostId: t/7/cecKuibFllp9EP+XbV2k6s70yO0/rnZGIEUTv9Uqq3Pfy5+u9ee8WbOB/CrKK/hlkExa9Kg= * * * ---