Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
RAIN.Action.ActionThe 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.ActionContextActionContext 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.AgentAgent 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.AIAnimationControllerAIAnimationController 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.AIAnimationExtenderThe 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.AIBehaviorAIBehavior 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.AICharacterControllerAICharacterController is used to translate movement requests from the RAIN motion system into CharacterController movement requests
RAIN.Motion.AIKinematicControllerAIKinematicController 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.AIMixamoAnimationController
RAIN.Motion.AIRigidBodyControllerThe 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.AnimateActionAnimateAction 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.AnimationMapAnimationMap 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.Motion.AIMixamoAnimationController.AnimationMap
RAIN.Animation.AnimationParams
RAIN.Animation.AnimationRequestHandlerAnimationRequestHandler 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.AspectAn Aspect defines an observable characterstic 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.AssignmentExpressionAssignmentExpression 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.AssignVariableActionAssignVariableAction 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.AvatarControllerAvatarController 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.BehaviorTreeMindBehaviorTreeMind 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.BoxObstacleAvoidanceColliderBoxObstacleAvoidanceCollider is a box implementation of the ObstacleAvoidanceCollider
RAIN.Sensors.BoxSensorBoxSensor is a simple sensor that uses a fixed size box collider to detect Aspects
RAIN.BehaviorTrees.BTActionNodeBTActionNode is the behavior leaf node representing an atomic action
RAIN.BehaviorTrees.BTActivationManagerBTActivationManager 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.BTConditionNodeBTConditionNode 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.BTDecoratorNodeDecoratorNode 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.BTIteratorNodeBehaviorTree iterator node. Iteration is initialized based on a count initializer expression, which may contain variables
RAIN.BehaviorTrees.BTLastStateNodeBTLastStateNode 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.BTNodeBTNode 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.BTParallelNodeBTParallelNode 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.BTRepeaterBTRepeater is a BTDecoratorNode used to cause another node to repeat until some return state is achieved
RAIN.BehaviorTrees.BTSelectorNodeBTSelectorNode 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.BTSequencerNodeBTSequencerNode executes a series of nodes. The child list order is assumed to be prioritized, so that children can be executed in order
RAIN.Belief.ConditionalExpressionConditionalExpression 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)
DecoratedDecorated is an interface used for any item that can hold decorations
RAIN.Ontology.DecorationA Decoration is a mechanism for adding various descriptions to an Entity
RAIN.Ontology.Describable
RAIN.Primitives.DetectActionDetectAction 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.EntityThe Entity class is the primary component used to identify Describable objects to RAIN
RAIN.Sensors.ExpandingBoxSensorExpandingBoxSensor is a BoxSensor that changes shape over time. ExpandingBoxSensor has a minimum size, maximum size, and expand rate (per axis)
RAIN.Belief.ExpressionExpression 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.FindPathToTargetFindPathToTarget 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.FollowPathFollowPath 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.GoalActionMindGoalActionMind 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.GOBActionNodeGOBActionNode 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.GOBGoalNodeGOBGoalNode 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.GOBInsistenceNodeRepresentation of an insistence measure for GOB
RAIN.GOB.GOBTree.GOBPersonalityInfluenceNode
RAIN.GOB.GOBTree.GOBTreeNode
RAIN.GOB.GOBTree.GOBUtilityNodeRepresentation of a utility function for GOB
RAIN.Action.IActionExecutorIActionExecutor 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.KinematicKinematic 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.LPAPathFinderLPAPathFinder is an implementation of the Lifelong Planning A* algorithm described in this research: http://idm-lab.org/project-a.html
RAIN.Path.LPAPathNodeHelperLPAPathNodeHelper is a special PathNodeHelper class designed specifically for LPA* pathfinding http://idm-lab.org/project-a.html
RAIN.Core.MindMind 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
MixamoAIAnimationExtenderMODIFY THIS SCRIPT TO MAKE THIS COMPONENT AVAILABLE FOR MIXAMO ANIMATION SUPPORT
RAIN.Primitives.MoveActionMoveAction 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.MoveLookTargetMoveLookTarget 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.MoveToTargetMoveToTarget 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.NavGridPathChooseMoveTargetWaypointPathChooseMoveTarget 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.NavGridRegion
RAIN.Sensors.NavigationGeometryColliderNavigationGeometryCollider is used to pick up general physics collider information that is relevant to navigation, either for obstacle avoidance or for real-time recast
RAIN.Action.NestedActionContext
RAIN.Core.Agent.NotAnAgentExceptionNotAnAgentException may be thrown if RAIN finds a significant error in the construction of the AI
RAIN.Ontology.ObservableObservable is an interface used for any object that can be tagged with observable Aspects
RAIN.Sensors.ObstacleAvoidanceColliderObstacleAvoidanceCollider 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.ParallelActionExecutorParallelActionExecutor 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.PathBasePathBase is the base interface for all Path implementations
RAIN.Path.PathEdgeBase 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.PathGizmoPathNodeGizmo is used to display a path node and its connections to its neighbors for graph visualization
RAIN.Path.PathGraphPathGraph is the base class for all PathGraph implementations
RAIN.Path.PathGraph.PathGraphChangedEventArgsA path graph changed event used to signal the pathfinding system that a recomputation may be necessary
RAIN.Path.PathGraphExceptionAn exception class associated with Path Graph functions
RAIN.Path.PathGraphPriorityHeapA priority heap class used for pathfinding. The heap is static in memory and contains graph.Size PathNodeHelper objects
RAIN.Path.BasicPathFollower.PathHelper
RAIN.Path.PathManagerPathManager is both a helper class for building pathfinding within the UnityEditor and a utility class for accessing path-based movement in RAIN
RAIN.Path.PathNodePathNode 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.PathNodeGizmoPathNodeGizmo is used to display a path node and its connections to its neighbors for graph visualization
RAIN.Path.PathNodeHelperPathNodeHelper is a helper class used in pathfinding to track the visited state and cost information
RAIN.Personality.PersonalityContextPersonalityContext contains a list of traits with specific bound influence measures
RAIN.Core.PhysicalEntityPhysicalEntity is a base class for objects that have a Kinematic structure
RAIN.Primitives.PlayAudioActionPlayAudioAction 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.RAINAgentRAINAgent represents the primary interface between RAIN AI and Unity
RAIN.Sensors.RaycastSensor
RAIN.Motion.Instantaneous.SB_AlignSB_Align is a steering behavior that aligns the AI orientation with that of a target
RAIN.Motion.Acceleration.SB_AlignSB_Align is a steering behavior that aligns the AI orientation with that of a target
RAIN.Motion.Instantaneous.SB_ArriveSB_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_ArriveSB_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_AvoidSB_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.Acceleration.SB_AvoidSB_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.Acceleration.SB_CohesionSB_Cohesion is a steering behavior that moves and agent toward the "center of mass" of a group
RAIN.Motion.Instantaneous.SB_CohesionSB_Cohesion is a steering behavior that moves and agent toward the "center of mass" of a group
RAIN.Motion.Instantaneous.SB_FaceSB_Face is a steering behavior that rotates the AI to face (look at) a target
RAIN.Motion.Acceleration.SB_FaceSB_Face is a steering behavior that rotates the AI to face (look at) a target
RAIN.Motion.Instantaneous.SB_FleeSB_Flee is a steering behavior that attempts to move the AI away from a target at maximum velocity
RAIN.Motion.Acceleration.SB_FleeSB_Flee is a steering behavior that attempts to move the AI away from a target at maximum acceleration
RAIN.Motion.Instantaneous.SB_LookWhereYoureGoingSB_LookWhereYoureGoing is a steering behavior that rotates the AI to align with its forward vector
RAIN.Motion.Acceleration.SB_LookWhereYoureGoingSB_LookWhereYoureGoing is a steering behavior that rotates the AI to align with its forward vector
RAIN.Motion.Instantaneous.SB_PursueSB_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_PursueSB_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_SeekSB_Seek is a steering behavior that steers directly toward a target with maximum velocity
RAIN.Motion.Acceleration.SB_SeekSB_Seek is a steering behavior that steers directly toward a target with maximum acceleration
RAIN.Motion.Instantaneous.SB_SeparateSB_Separate is a steering behavior that attempts to keep some distance from nearby targets
RAIN.Motion.Acceleration.SB_SeparateSB_Separate is a steering behavior that attempts to keep some distance from nearby targets
RAIN.Motion.Acceleration.SB_StopMovingSB_StopMoving will attempt to negate any current movement and produce 0 velocity and 0 rotation
RAIN.Motion.Instantaneous.SB_StopMovingSB_StopMoving will attempt to negate any current movement and produce 0 velocity and 0 rotation
RAIN.Motion.Acceleration.SB_WanderSB_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.Instantaneous.SB_WanderSB_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.SensationSensation 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.SensorSensor is the base class for all Sensor types. It defines default and support functionality for Sensors and defines the Sensor interface
RAIN.Action.SequentialActionExecutorSequentialActionExecutor is a basic executor that executes contained Actions in sequence, waiting for each Action to complete successfully before beginning the next Action
RAIN.Minds.SimpleMindSimpleMind 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.SphereObstacleAvoidanceColliderSphereObstacleAvoidanceCollider is a sphere implementation of the ObstacleAvoidanceCollider
RAIN.Sensors.SphereSensorSphereSensor is a simple sensor that uses a fixed size sphere collider to detect Aspects
RAIN.Motion.Acceleration.SteeringSteering represents the output of SteeringBehaviors as an acceleration request and an angular acceleration request
RAIN.Motion.Instantaneous.SteeringSteering represents the output of SteeringBehaviors as a velocity request and an angularvelocity (rotation) request
RAIN.Motion.Acceleration.SteeringBehaviorSteeringBehavior 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.SteeringBehaviorSteeringBehavior 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.TeleoReactiveActionExecutorTeleoReactiveActionExecutor 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.TraitTrait 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.WaypointWaypoint defines a node in a waypoint navigation graph setup
RAIN.Path.WaypointGizmo
RAIN.Path.WaypointPathChooseMoveTargetWaypointPathChooseMoveTarget 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.Path2.WaypointPathGraph
RAIN.Path.WaypointPathNode