| RAIN.Action.Action | The Action class defines the basic functionality of any low-level action. An Action can be Started, Executed, or Stopped. Actions have an ActionName to help identify them during debugging, and an ActionContext that serves as a kind of "blackboard" for transmitting information between actions that are working together |
| RAIN.Action.ActionContext | ActionContext serves as a kind of shared memory context, or "blackboard", for Actions that work together to complete a task. ActionContext works as a typed name/value pair, with only one value allowed per name |
| RAIN.Core.Agent | Agent is the base class for AI. Generally if you are using RAIN you will not want to create instances on your own. However, you may want to use key methods of this class to manipulate your AI |
| RAIN.Motion.AIAnimationController | AIAnimationController is the motion controller for AI whose motion is driven by or strongly linked to animation. AIAnimationController requires the attachment of an AIAnimationExtender. For Mixamo animations, use the supplied MixamoAIAnimationExtender script provided with RAIN. You may also write your own AIAnimationExtender to link motion control to your custom animation rig |
| RAIN.Motion.AIAnimationExtender | The AIAnimationExtender is a component that should be added to AI Avatars that need to manipulate animations from AI Logic. The AIAnimationExtender works in conjunction with Behavior Trees and with Motion to support handling of various animation callbacks |
| RAIN.Core.AIBehavior | AIBehavior is the base class for most AI scripting. AIBehavior replaces MonoBehavior and uses a modified Start/Update system to support the AI thinking pipeline. AIBehavior is typically managed by the Mind associated with an AI, which controls the timing and activation of the AIBehavior code. The contents of the InitBehavior and Act methods are up to the developer, but typically contain AI specific code that utilizes other supporting RAIN functions such as Steering, Pathfinding, Sensors, etc |
| RAIN.Motion.AICharacterController | AICharacterController is used to translate movement requests from the RAIN motion system into CharacterController movement requests |
| RAIN.Motion.AICustomController | AICustomController defines the same basic capabilities as AIKinematicController but provides a more extensible framework for modifying control, physics and animation |
| RAIN.Motion.AIKinematicController | AIKinematicController is used to enforce direct control over AI position. AIKinematic controller translates movement requests from the RAIN motion system directly into position and orientation transforms on the Avatar game object |
| RAIN.Motion.AIRigidBodyController | The AIRigidBodyController is intended to translate movement requests from the RAIN motion system into physics forces suitable for rigid body objects whose motion is controlled by rigid body physics |
| RAIN.Primitives.AnimateAction | AnimateAction is a primitive that can be used to manipulate animation in RAIN characters. The easiest way to link animation to your character is by adding an AnimationRequestHandler to it - either directly or through a controller that supports IAnimationRequestHandler (e.g., an AIAnimationController) |
| RAIN.Motion.AIAnimationController.AnimationMap | AnimationMap is used to map an animation state to a set of motion parameters that help RAIN to determine when to transition to a given state |
| RAIN.Animation.AnimationParams | |
| RAIN.Animation.AnimationRequestHandler | AnimationRequestHandler is a stub class/component that can be added to a game object to quickly provide support for Animation driven by AI It is a simple imlementation of the IAnimationRequestHandler interface, which defines the methods RAIN will use to manipulate animation |
| RAIN.Ontology.Aspect | An Aspect defines an observable characteristic of an object. Aspects are identified by their name and by the sensation that would be used to detect the Aspect. Aspects do not themselves have definitions, but instead are defined entirely by their relationship (coexistence with) other Aspects and the interpretation of the sensing entity |
| RAIN.Belief.AssignmentExpression | AssignmentExpression represents a variable assignment expression similar to a C++ or C# assignment. Assignments can be represented as a left-hand-side (lhs), right-hand-side (rhs) and an infix operator (op) as in (lhs op rhs). Operators supported are EQ, PLUSEQ, MINUSEQ, TIMESEQ, DIVIDEEQ Nested expressions and expressions with variables are supported. lhs must be a single variable name |
| RAIN.Primitives.AssignVariableAction | AssignVariableAction is a primitive action used to execute an AssignmentExpression. A min and max value can be set to limit the range of the variable assigned to |
| RAIN.Motion.AvatarController | AvatarController is the base class for all AIControllers in RAIN. When using or extending the controller, keep in mind that the controller methods are automatically called by a RAINAgent during Update and LateUpdate. UpdateFromAvatar is used to make your agent.Kinematic up to date before Think and Act calls occur. CalculatePhysics is used to update the Kinematic based on forces stored in Kinematic.Set/AddForces or Kinematic.Set/AddVelocity. ApplyPhysicsToAvatar is used to push Kinematic changes back to the game object |
| RAIN.Path.BasicPathFollower | |
| RAIN.Minds.BehaviorTreeMind | BehaviorTreeMind is a Mind setup designed to integrate with the RAIN Behavior Tree system. Upon initialization, this mind will load the behavior tree designated by behaviorTreeFilename. It will then use the attached BTActivationManager to InitBehavior, SetVariables, and Act. This causes the BehaviorTree to be evaluated and executed at each timestep, with results applied to the agent owning this Mind |
| RAIN.Sensors.BoxObstacleAvoidanceCollider | BoxObstacleAvoidanceCollider is a box implementation of the ObstacleAvoidanceCollider |
| RAIN.Sensors.BoxSensor | BoxSensor is a simple sensor that uses a fixed size box collider to detect Aspects |
| RAIN.BehaviorTrees.BTActionNode | BTActionNode is the behavior leaf node representing an atomic action |
| RAIN.BehaviorTrees.BTActivationManager | BTActivationManager is an AIBehavior associated with a BehaviorTreeMind responsible for managing execution of a behavior tree and interacting with user code to perform pre-treetraversal steps such as per frame variable binding |
| RAIN.BehaviorTrees.BTConditionNode | BTConditionNode is a behavior tree leaf node that evaluates a conditional expression to either true or false. A true evaluation will return an ActionResult of SUCCESS. A false evaluation will return an ActionResult of FAILURE. More complex computational evaluations must be coded as BTActionNodes |
| RAIN.BehaviorTrees.BTDecoratorNode | DecoratorNode is the abstract base class for behavior tree nodes that are intended as passthrough decorators that proxy for their child but add some intermediate functionality |
| RAIN.BehaviorTrees.BTIteratorNode | BehaviorTree iterator node. Iteration is initialized based on a count initializer expression, which may contain variables |
| RAIN.BehaviorTrees.BTLastStateNode | BTLastStateNode is a BTDecoratorNode used to record the last state of the decorated node. This is used by the BTParallelNode to keep track of how child nodes should be processed based on their prior results |
| RAIN.BehaviorTrees.BTNode | BTNode is the abstract base class for all behavior tree nodes. BTNode is an Action, so all BTNodes conform to the standard Start(), Execute(), Stop() protocol and return ActionResults |
| RAIN.BehaviorTrees.BTParallelNode | BTParallelNode is a behavior tree node for allowing child nodes to operate in parallel. Since Unity runs behavior single threaded, nodes are processed in priority order (pre-sorted). However, at each Execute step all active children are given an opportunity to execute even if higher priority nodes fail |
| RAIN.BehaviorTrees.BTRandomNode | BTRandomNode executes a single node from a set of nodes, choosing the node to execute at random |
| RAIN.BehaviorTrees.BTRepeater | BTRepeater is a BTDecoratorNode used to cause another node to repeat until some return state is achieved |
| RAIN.BehaviorTrees.BTSelectorNode | BTSelectorNode chooses one of a set of options. The child list order is assumed to be prioritized, so that children can be evaluated in order |
| RAIN.BehaviorTrees.BTSequencerNode | BTSequencerNode executes a series of nodes. The child list order is assumed to be prioritized, so that children can be executed in order |
| RAIN.BehaviorTrees.BTTimerNode | BTTimerNode waits and returns RUNNING until the timer expires, then returns SUCCESS. BTTimerNode never returns FAILURE |
| RAIN.BehaviorTrees.BTYieldNode | BTBreakNode is used to break execution of a behavior tree for improving performance and causing execution to pause and resume next frame |
| RAIN.Belief.ConditionalExpression | ConditionalExpression represents a logical expression similar to a C++ or C# conditional. Conditionals can be represented as a left-hand-side (lhs), right-hand-side (rhs) and an infix operator (op) as in (lhs op rhs). Operators supported are GT, LT, GE, LE, EQ, NEQ, APPROX, NAPPROX, NO_OP Nested expressions and expressions with variables are supported. (i.e., lhs and rhs can be any valid Expression) |
| RAIN.Path.CustomPathManager | PathManager is both a helper class for building pathfinding within the UnityEditor and a utility class for accessing path-based movement in RAIN |
| RAIN.Primitives.DebugAction | DebugAction is a primitive that is used to post a single debug message to the Unity log |
| RAIN.Ontology.Decorated | Decorated is an interface used for any item that can hold decorations |
| RAIN.Ontology.Decoration | A Decoration is a mechanism for adding various descriptions to an Entity |
| RAIN.Ontology.Describable | |
| RAIN.Primitives.DetectAction | DetectAction is a primitive that is used to detect an object with a certain aspect, then assign the object to a variable in the Agent's actionContext |
| RAIN.Ontology.Entity | The Entity class is the primary component used to identify Describable objects to RAIN |
| RAIN.Sensors.ExpandingBoxSensor | ExpandingBoxSensor is a BoxSensor that changes shape over time. ExpandingBoxSensor has a minimum size, maximum size, and expand rate (per axis) |
| RAIN.Belief.Expression | Expression is used to represent math calculations that can be evaluated into float numbers. Expressions are usually entered as text representations similar to Java or C# expressions. Expressions may be nested and may contain variables. The variable "t" always represents time, and is always bound to deltaTime during expression evaluation. Expressions are used throughout RAIN in Goal Oriented Behavior and Behavior Trees |
| RAIN.Path.FindPathToTarget | FindPathToTarget is an Action that uses the AI Agent position and ContextItems.TARGET as begin and end points, then constructs a path using ContextItems.PATHGRAPH, inserting the final result in ContextItems.PATH_TO_TARGET |
| RAIN.Path.FollowPath | FollowPath is a helper Action that combines two other Actions. FollowPath first chooses a movement target using chooseAction, then moves to the target using moveAction. ContextItems constants are expected to be set and used, including PATHGRAPH, PATH_TO_TARGET, TARGET, and MOVE_TO_TARGET |
| RAIN.Minds.GoalActionMind | GoalActionMind is here for legacy reasons. It is now just a behavior tree mind, since Goal Oriented Behavior has been integrated with behavior trees |
| RAIN.GOB.GOBTree.GOBActionNode | GOBActionNode is a special action type for GoalOrientedBehavior. GOBActionNodes are used to predict the change in world state caused by execution of their associated actions. The predictions are fed into the goal evaluation step and used to calculate an overall utility. GOB then chooses an action based on maximum overall utility |
| RAIN.GOB.GOBTree.GOBGoalNode | GOBGoalNode represents high level goals in Goal Oriented Behavior (GOB). These goals may not be tied directly to actions (i.e., not 1 to 1) but instead represent preferrable world states. GOBGoals have insistence functions that produce a "discomfort level", which can be translated to the urgency to which the goal requires satisfaction. GOB operates by choosing choosing actions which are predicted to do the best job of reducing overall discomfort/urgency |
| RAIN.GOB.GOBTree.GOBInsistenceNode | Representation of an insistence measure for GOB |
| RAIN.GOB.GOBTree.GOBPersonalityInfluenceNode | |
| RAIN.GOB.GOBTree.GOBTreeNode | |
| RAIN.GOB.GOBTree.GOBUtilityNode | Representation of a utility function for GOB |
| RAIN.Path.Dynamic.GraphModifier | GraphModifier allows you to change the weights and graph connectivity of overlapping graph regions |
| RAIN.Action.IActionExecutor | IActionExecutor is an add-on interface used by ActionExecutors to support setup and management of Actions and Action execution. Most ActionExecutors will implement Action and support IActionExecutor |
| RAIN.Animation.IAnimationRequestHandler | |
| RAIN.Core.Kinematic | Kinematic is used to define physical information about an object or about the AI. This includes position and orientation, rotation and velocity, and acceleration. Kinematic is also used to combine and apply forces |
| RAIN.Path.LPAPathFinder | LPAPathFinder is an implementation of the Lifelong Planning A* algorithm described in this research: http://idm-lab.org/project-a.html |
| RAIN.Path.LPAPathNodeHelper | LPAPathNodeHelper is a special PathNodeHelper class designed specifically for LPA* pathfinding http://idm-lab.org/project-a.html |
| RAIN.Core.Mind | Mind is the base class for creating specific Mind types that assist in organizing "thinking" strategies. Mind provides access to various RAIN resources, specifically around Sensors and memory retrieval. Mind is also responsible for controlling the Think/Act cycle |
| MixamoAIAnimationExtender | MODIFY THIS SCRIPT TO MAKE THIS COMPONENT AVAILABLE FOR MIXAMO ANIMATION SUPPORT |
| RAIN.Primitives.MoveAction | MoveAction is a primitive used to specify a target location to move to, speed at which to move, and optionally an animation to play while moving |
| RAIN.Path.MoveLookTarget | MoveLookTarget is a class that supports multiple representations of a possible target position, including a Transform (GameObject), Kinematic (like those used by Agents), or simple Vector3 |
| RAIN.Path.MoveToTarget | MoveToTarget is an Action that attempts to use Instantaneous steering behaviors SB_Arrive and SB_Face to move toward the position identified by ContextItems.MOVE_TARGET |
| RAIN.Path.NavGridArray | |
| RAIN.Path.NavGridMultiRegionGraph | |
| RAIN.Path.NavGridPathChooseMoveTarget | NavGridPathChooseMoveTarget is an Action that chooses a movement target based on moving forward-only through a set of waypoints. This Action depends on loading a NavGridPathGraph rather than an arbitrary path graph |
| RAIN.Path.NavGridRegion | |
| RAIN.Sensors.NavigationGeometryCollider | NavigationGeometryCollider is used to pick up general physics collider information that is relevant to navigation |
| RAIN.Action.NestedActionContext | |
| RAIN.Core.Agent.NotAnAgentException | NotAnAgentException may be thrown if RAIN finds a significant error in the construction of the AI |
| RAIN.Ontology.Observable | Observable is an interface used for any object that can be tagged with observable Aspects |
| RAIN.Sensors.ObstacleAvoidanceCollider | ObstacleAvoidanceCollider is the base class for obstacle avoidance colliders. It is an abstract class, serving as a common base upon which specific collider types (sphere, box, etc.) can be added |
| RAIN.Action.ParallelActionExecutor | ParallelActionExecutor is a basic executor that executes all contained Actions in parallel. Since RAIN{one} is not multi-threaded, Actions are executed in sequence, but each Action will get an opportunity to Execute before control is returned |
| RAIN.Path.PathBase | PathBase is the base interface for all Path implementations |
| RAIN.Path.PathEdge | Base class for PathEdge representation. Path edges are directed edges with associated costs, used for graph traversal in directed graphs. Path edges have statically defined costs plus an associated Cost function. Edges are always one way |
| RAIN.Path.PathGraph | PathGraph is the base class for all PathGraph implementations |
| RAIN.Path.PathGraph.PathGraphChangedEventArgs | A path graph changed event used to signal the pathfinding system that a recomputation may be necessary |
| RAIN.Path.PathGraphException | An exception class associated with Path Graph functions |
| RAIN.Path.PathGraphPriorityHeap | A priority heap class used for pathfinding. The heap is static in memory and contains graph.Size PathNodeHelper objects |
| RAIN.Path.BasicPathFollower.PathHelper | |
| RAIN.Path.PathManager | |
| RAIN.Path.PathNode | PathNode is the base class for all path graph nodes. Path node typically consists of a node index and incoming and outgoing edge lists |
| RAIN.Path.PathNodeHelper | PathNodeHelper is a helper class used in pathfinding to track the visited state and cost information |
| RAIN.Personality.PersonalityContext | PersonalityContext contains a list of traits with specific bound influence measures |
| RAIN.Core.PhysicalEntity | PhysicalEntity is a base class for objects that have a Kinematic structure |
| RAIN.Primitives.PlayAudioAction | PlayAudioAction is a primitive that supports playback of sound effects. To set up the PlayAudioAction primitive, ensure that the audio you want to play is an AudioSource attached to a child of the Avatar. The audioSourceName variable should be set to the name of the child object |
| RAIN.Core.RAINAgent | RAINAgent represents the primary interface between RAIN AI and Unity |
| RAIN.Core.RAINComponent | RAINComponent is the base class for all RAIN components. Currently it is only used to track version information |
| RAIN.Path.RAINPathManager | RAINPathManager is both a helper class for building pathfinding within the UnityEditor and a utility class for accessing path-based movement in RAIN |
| RAIN.Sensors.RaycastSensor | |
| RAIN.Motion.Instantaneous.SB_Align | SB_Align is a steering behavior that aligns the AI orientation with that of a target |
| RAIN.Motion.Acceleration.SB_Align | SB_Align is a steering behavior that aligns the AI orientation with that of a target |
| RAIN.Motion.Acceleration.SB_Arrive | SB_Arrive is a steering behavior used to move to a target and arrive smoothly (slowing down as you get there). This only impacts position, not orientation |
| RAIN.Motion.Instantaneous.SB_Arrive | SB_Arrive is a steering behavior used to move to a target and arrive smoothly (slowing down as you get there). This only impacts position, not orientation |
| RAIN.Motion.Acceleration.SB_Avoid | SB_Avoid is a steering behavior that produces an avoidance Steering output based on calculating shortest time to collision among a group of targets, then attempting to avoid just that target |
| RAIN.Motion.Instantaneous.SB_Avoid | SB_Avoid is a steering behavior that produces an avoidance Steering output based on calculating shortest time to collision among a group of targets, then attempting to avoid just that target |
| RAIN.Motion.Instantaneous.SB_Cohesion | SB_Cohesion is a steering behavior that moves and agent toward the "center of mass" of a group |
| RAIN.Motion.Acceleration.SB_Cohesion | SB_Cohesion is a steering behavior that moves and agent toward the "center of mass" of a group |
| RAIN.Motion.Acceleration.SB_Face | SB_Face is a steering behavior that rotates the AI to face (look at) a target |
| RAIN.Motion.Instantaneous.SB_Face | SB_Face is a steering behavior that rotates the AI to face (look at) a target |
| RAIN.Motion.Acceleration.SB_Flee | SB_Flee is a steering behavior that attempts to move the AI away from a target at maximum acceleration |
| RAIN.Motion.Instantaneous.SB_Flee | SB_Flee is a steering behavior that attempts to move the AI away from a target at maximum velocity |
| RAIN.Motion.Instantaneous.SB_LookWhereYoureGoing | SB_LookWhereYoureGoing is a steering behavior that rotates the AI to align with its forward vector |
| RAIN.Motion.Acceleration.SB_LookWhereYoureGoing | SB_LookWhereYoureGoing is a steering behavior that rotates the AI to align with its forward vector |
| RAIN.Motion.Acceleration.SB_Pursue | SB_Pursue is a steering behavior that attempts to steer toward the future position of a target based on its current velocity |
| RAIN.Motion.Instantaneous.SB_Pursue | SB_Pursue is a steering behavior that attempts to steer toward the future position of a target based on its current velocity |
| RAIN.Motion.Acceleration.SB_Seek | SB_Seek is a steering behavior that steers directly toward a target with maximum acceleration |
| RAIN.Motion.Instantaneous.SB_Seek | SB_Seek is a steering behavior that steers directly toward a target with maximum velocity |
| RAIN.Motion.Acceleration.SB_Separate | SB_Separate is a steering behavior that attempts to keep some distance from nearby targets |
| RAIN.Motion.Instantaneous.SB_Separate | SB_Separate is a steering behavior that attempts to keep some distance from nearby targets |
| RAIN.Motion.Acceleration.SB_StopMoving | SB_StopMoving will attempt to negate any current movement and produce 0 velocity and 0 rotation |
| RAIN.Motion.Instantaneous.SB_StopMoving | SB_StopMoving will attempt to negate any current movement and produce 0 velocity and 0 rotation |
| RAIN.Motion.Instantaneous.SB_Wander | SB_Wander is a steering behavior that attempts to produce a random wandering motion Wandering is defined by steering toward a target rotating randomly around a circle at some distance in front of the AI |
| RAIN.Motion.Acceleration.SB_Wander | SB_Wander is a steering behavior that attempts to produce a random wandering motion Wandering is defined by steering toward a target rotating randomly around a circle at some distance in front of the AI |
| RAIN.Ontology.Sensation | Sensation identifies the type of Sensation that a Sensor can detect or that an Aspect is associated with. By default Sensation includes definitions for SIGHT, TOUCH, SOUND, SMELL, and TASTE, although any sensation name may be given |
| RAIN.Sensors.Sensor | Sensor is the base class for all Sensor types. It defines default and support functionality for Sensors and defines the Sensor interface |
| RAIN.Action.SequentialActionExecutor | SequentialActionExecutor is a basic executor that executes contained Actions in sequence, waiting for each Action to complete successfully before beginning the next Action |
| RAIN.Minds.SimpleMind | SimpleMind is a Mind setup designed to allow developers to create a list of AIBehaviors that are executed in order at each timestep. The Mind manages execution of the behaviors |
| RAIN.Path.SimplePath | |
| RAIN.Sensors.SphereObstacleAvoidanceCollider | SphereObstacleAvoidanceCollider is a sphere implementation of the ObstacleAvoidanceCollider |
| RAIN.Sensors.SphereSensor | SphereSensor is a simple sensor that uses a fixed size sphere collider to detect Aspects |
| RAIN.Motion.Instantaneous.Steering | Steering represents the output of SteeringBehaviors as a velocity request and an angularvelocity (rotation) request |
| RAIN.Motion.Acceleration.Steering | Steering represents the output of SteeringBehaviors as an acceleration request and an angular acceleration request |
| RAIN.Motion.Acceleration.SteeringBehavior | SteeringBehavior is the base class for all steering behaviors. SteeringBehaviors should override whichever Steer methods they support and leave the rest unchanged. Unhandled behaviors will return an empty (no-op) steering |
| RAIN.Motion.Instantaneous.SteeringBehavior | SteeringBehavior is the base class for all steering behaviors. SteeringBehaviors should override whichever Steer methods they support and leave the rest unchanged. Unhandled behaviors will return an empty (no-op) steering |
| RAIN.Action.TeleoReactiveActionExecutor | TeleoReactiveActionExecutor is an ActionExecutor that attempts to execute a set of Actions as a simple "fallback" plan. At each step, the "best case" Action is selected and attempted to execute. If that Action fails, the next best case is chosen. If any Action succeeds, the executor immediately returns SUCCESS. Action selection is carried out by choosing the last item in the execution list. Selection proceeds by continuing to select the prior action in the sequence until SUCCESS or no Actions remain. To build an Action stack, add the most basic Action as element 0. Add the next as element 1, etc. The created stack can be considered a "plan" to the extent that executing Action 0 creates necessary preconditions for the success of Action 1. Action 1 creates necessary preconditions for the success of Action 2, etc. The created stack can be considered "TeleoReactive" to the extent that execution is opportunistic. The executor always attempts to carry out the last Actions in the sequence, "just in case" they may work |
| RAIN.Personality.Trait | Trait is a named personality influence that can be applied to other behavior measures to alter behavior |
| RAIN.Sensors.TriggerSensor | |
| RAIN.Path.VectorPathGraph | |
| RAIN.Path.VectorPathNode | |
| RAIN.Path.Waypoint | Waypoint defines a node in a waypoint navigation graph setup |
| RAIN.Path.WaypointGizmo | |
| RAIN.Path.WaypointPathChooseMoveTarget | WaypointPathChooseMoveTarget is an Action that chooses a movement target based on moving forward-only through a set of waypoints. This Action depends on loading a WaypointPathGraph rather than an arbitrary path graph |
| RAIN.Path.WaypointPathFollower | |
| RAIN.Path.WaypointPathGraph | |
| RAIN.Path.WaypointPathNode | |
| RAIN.Path.Waypoints.WaypointQuantization | |