Components
==========

.. code-block:: cpp

    public struct ASAgent : IComponentData //Basic Agent
    {
        public float MaxSpeed; //Speed of agent when moving
        public float Radius; //Radius of Agent
        public float Height; //Height of Agent
        public float TurnSpeed; //Turn speed when moving

        public float NextTargetTouchDistance; //When moving from point to point in the path, this is the min distance that the agent will find enough to consider point reached (best value tends to be Grid.NodeSize but can vary, setting this value to a negative value will automatically use Grid.NodeSize)

        public bool IgnoreAvoidanceWhenDestReached; //Stop being condidered as an avoidance agent if destination is reached, even if ASAvoidanceAgent is still attached.

        public float StoppingDistance; //Distance from target point to consider it reached
        public float3 CurrentVelocity; //Current Agent Velocity
    }

.. code-block:: cpp

    public struct ASPathFollower : IComponentData //Path following data
    {
        public bool PathAvailable; //Is path available ?
        public int TargetIndex; //Point index in ASPathBufferComponent that is being persued
        public bool DestinationReached; //Is destination reached ?
    }

.. code-block:: cpp

    public struct ASPathfindingRequester : IComponentData //Requests paths from the pathfindind system
    {
        public float3 Destination; //Destination point
        public bool RequestGiven; //Is path given to the requester system ? Set this to false to request new path
        public Entity RequestEntity; //Request entity being managed by the pathfindider (don't set this, it will be set by the requester system)
    }

.. code-block:: cpp

    public struct ASConstantTargetFollower : IComponentData //Attach this for contant following of a target entity
    {
        public Entity Target; //Target entity to be followed (!!! Has to have a LocalTransform)
        public bool RecalculateOnStationary; //Recalucate even if target does not move (Not recommended to set this to true, unless environment is changing constantly)
        public float3 TargetLastPosition; //This position keeps track to know whether or not the target moved
    }

.. code-block:: cpp

    public struct ASAvoidanceAgent : IComponentData //Avoidance agent, attach this to agent or it will be ignored by avoidance
    {
        public float TimeHorizon; //How far in the future to predict collision (standard value is 2)
    }

.. code-block:: cpp

    [InternalBufferCapacity(0)] //Store all agents in heap
    public struct ASAgentNeighboursBufferComponent : IBufferElementData //The neighbours that will be taken into account by avoidance, must be attached to agent along an ASAvoidanceAgent, but not set as it will be set automatically
    {
        public Entity Agent; //Neighbour Agent
    }

.. code-block:: cpp

    public struct ASPathfindingOperation : IComponentData //A pathfinding operation, created by path requester
    {
        public float3 StartPoint; //Starting point
        public float3 TargetPoint; //End point
    }

.. code-block:: cpp

    [InternalBufferCapacity(0)] //Store points in heap
    public struct ASPathBufferComponent : IBufferElementData //Pathpoints for the agent to follow
    {
        public float3 Point; //Point for agent to go to
    }

.. code-block:: cpp

    public struct ASPathfindingResult : IComponentData //Result from pathfinding operation
    {
        public bool PathFound; //Was path found ?
        public bool FinishedSearch; // Was operation complete ?
    }

.. code-block:: cpp

    [InternalBufferCapacity(0)] //Store operations in heap
    public struct ASPathfindingOperationsBuffer : IBufferElementData //the queue buffer that stores the pathfinding operations
    {
         public Entity RequestingAgentEntity; //Agent that is sending the request
         public ASPathfindingOperation Operation; //The operation
    }

.. code-block:: cpp

        public struct ASGrid : IComponentData //Grid
    {
        public float Width, Height; //Total width and height of grid
        public int NodeXCount, NodeYCount; //Width/NodeSize and Height/NodeSize
        public int InaccessibleLMIndex; //LayerMask value of Inaccessible nodes
        public int PenaltyLMIndex; //LayerMask value of Penalty nodes
        public float NodeSize; //Size of grid node
        public DifferentIslandsPolicy DifferentIslandsPolicy; //The grid will be seperated into islands, each island being an area closed off by inaccessible nodes
                                                                //What to do when an agent requests a path on different islands
                                                                //Don't Path : Does not compute the path at all
                                                                //Go to closest : Goes to the closest no on the agents island (WARNING: this is not recommended
                                                                //if you have many agents and a dense grid )
        public int TargetInaccessibleSearchTolerance; //if target is an inaccessible node, how far to to look for an accessible node in a radial direction (best between 10-20 increasing with grid density)
        public int AvoidanceNeighbours; //Max Number of avoidance neighbour agents per agent, (best between 4 and 10)
        public bool RecalcPathsAfterGridRefresh; //Reclculate paths for agents after grid refresh ?
        public bool RefreshGrid; //Set it to true after adding or moving a new obstacle/penalty to reset nodes
        public bool RefreshIslands; //Automatically set to true (after grid refresh) to refresh islands
    }

.. code-block:: cpp

    public struct ASNodeIslandIDBufferComponent : IBufferElementData  //2D flattened array of nodes, contains the ids of each node
    {
        public int IslandID;
    }

.. code-block:: cpp

    public struct ASPathfindingParameters : IComponentData //Additional PathfindingParameters
    {
        public int MaxPathfindingOpsPerFrame; //Max number of pathfinding operations to calculate per frame
    }

.. code-block:: cpp

    [InternalBufferCapacity(0)]
    public struct ASGridNodesBufferComponent : IBufferElementData   //2D flattened array of nodes
    {
        public ASNode Node; //Node in grid
    }

.. code-block:: cpp

    public struct ASNode : IEquatable<ASNode>, IHeapItem<ASNode> //Node
    {
        public bool IsAccessible; //Is node accessible/walkable ?
        public int X, Y; //X and Y coords of Node

        public int GCost; //G cost for A* algo
        public int HCost; //H cost for A* algo

        public int Penalty; //Penalty on node, makes it less appealing to walk on

        public int HeapIndex; //Min heap index

        public int PreviousNodeIndex; //Used to retrace path when pathfinding system finds target point
    }

.. code-block:: cpp

    public struct ASObstacle : IComponentData //Obstacle, must be attached on a collider with set layer mask
    {
        public int PenaltyOnObstacleValue; //An obstacle can have a penalty to make walking near it's edges less appealing for agents
    }

.. code-block:: cpp

    public struct ASPenalty : IComponentData //Path penalty, must be attached on a collider with set layer mask
    {
        public int PenaltyValue; //A penalty makes walking on the nodes less appealing, useful for creating paths etc...
    }