• Data Tag: This is a unique identifier for the GameObject, used by the manager to link data to that GameObject. It can be anything: some built-in components use an auto-generated Unique ID, but it could also be a manually typed name, like "Zone_3_key" or "Quest_Item_Card".
• Persistence Type: There are four types of persistence:
• Don't Persist: This allows disabling persistence. This is useful for GameObjects that need to be reset on Scene change (e.g. you may want a door to close again when restarting a level).
• Read Only: This GameObject can only read data, not write to it. A way to use this is to have a GameObject with Write Only (see below) with the same Data Tag. This GameObject uses the data that the other GameObject writes for that tag, but is not able to write over it.
• Write Only: The GameObject can write data but can't read from it. See Read Only above for example of use.
• Read Write: This is the most common case of use. The GameObject reads and writes data with its given Data Tag.

• Make your new class inherit SceneLinkedSMB. As the class is a Generic, you need to specify the type of the MonoBehaviour that it should hold. For example: public class EnemyAttackState: SceneLinkedSMB<Enemy>
• Initialize on every GameObject with an animator using that state. In the above example, we could add the following line to the Start() function of Enemy class: SceneLinkedSMB<Enemy>.Initialise(animator, this); In this example, animator is a reference to the animator with a state which has a SceneLinkedSMB<Enemy> on. Note that you only need to call this once, even if you have 10 differents scripts on multiples states. As long as they all inherit from SceneLinkedSMB<Enemy> they will all get initialized.
• Override any state functions you need. More functions are added to SceneLinkedSMB to allow for more specific control of when functionality happens. In your class you can access a protected member called m_MonoBehaviour that has the same type as the class’s generic type parameter. So continuing our example, m_MonoBehaviour would be of type Enemy.

public class Enemy: MonoBehaviour
{
    Animator animator;

    void Start()
   {
        animator = GetComponent<Animator>();
        SceneLinkedSMB<Enemy>.Initialise(animator, this);
    }

    public void TrickerAttack()
   {
    // ...
    }
}

public class EnemyAttackState: SceneLinkedSMB<Enemy>
{
    public override void OnSLStateEnter (Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        // m_MonoBehaviour is of type Enemy 
        m_MonoBehaviour.TrickerAttack ();
    }
}

• inPool: This bool determines whether or not the PoolObject is currently in the pool or is awake.
• instance: This GameObject is the instantiated prefab that this PoolObject wraps.
• objectPool: This is the object pool to which this PoolObject belongs. It has the same type as the ObjectPool type of this class.

• SetReferences: This is called once when the PoolObject is first created. Its purpose is to cache references so that they do not need to be gathered whenever the PoolObject is awoken, although it can be used for any other one-time setup.
• WakeUp: This is called whenever the PoolObject is awoken and gathered from the pool. Its purpose is to do any setup required every time the PoolObject is used. If the classes are given a third generic parameter then WakeUp can be called with a parameter of that type.
• Sleep: This is called whenever the PoolObject is returned to the pool. Its purpose is to perform any tidy up that is required after the PoolObject has been used.
• ReturnToPool: By default this simply returns the PoolObject to the pool but it can be overridden if additional functionality is required.

• Prefab: This is a reference to the prefab that is instantiated multiple times to create the pool.
• InitialPoolCount: The number of PoolObjects that are created in the Start method.
• Pool: A list of the PoolObjects.

• Start: This is where the initial pool creation happens. You should note that if you have a Start function in your ObjectPool it effectively hides the base class version.
• CreateNewPoolObject: This is called when PoolObjects are created and calls their SetReferences and then Sleep functions. It is not virtual, so it cannot be overridden but it is protected and can therefore be called in your inheriting class if you wish.
• Pop: This is called to get a PoolObject from the pool. By default it searches for the first one that has the inPool flag set to true and return that. If none are true it creates a new one and returns that. It calls WakeUp on whichever PoolObject is going to be returned. This is virtual and can be overridden.
• Push: This is called to put a PoolObject back in the pool. By default it just sets the inPool flag and calls Sleep on the PoolObject but it is virtual and can be overridden.

• Prefab: This is the bullet prefab you wish to use.
• Initial Pool Count: This is how many bullets are created in the pool to start with. It should be as many as you expect to be used at once. If more are required they are created at runtime.
• Pool: This is the BulletObjects in the pool. This is not shown in the inspector.

• Pop: Use this to get one of the BulletObjects from the pool.
• Push: Use this to put a BulletObject back into the pool.
• GetObjectPool: This is a static function that finds an appropriate BulletPool given a specific prefab.

• InPool: Whether or not this particular bullet is in the pool or being used.
• Instance: The instantiated prefab.
• ObjectPool: A reference to the BulletPool this BulletObject belongs to.
• Transform: A reference to the Transform component of the instance.
• Rigidbody2D: A reference to the Rigidbody2D component of the instance.
• SpriteRenderer: A reference to the SpriteRenderer component of the instance.
• Bullet: A reference to the Bullet script of the instance.

• WakeUp: This is called by the BulletPool when its Pop function is called.
• Sleep: This is called by the BulletPool when its Push function is called.
• ReturnToPool: This should be called when you are finished with a particular bullet. It calls the Push function of its BulletPool and so calls its Sleep function.

• Success: the node successfully finished its task.
• Failure: the node failed the task.
• Continue: the node didn't finish the task yet.

• *Selector makes the next child active if the current one returns Failure or Success, and keeps the current one active if it returns Continue.*
• *Test nodes call their child nodes and return the child state if the test is true, or return Failure without calling their child nodes if the test is false.*

• First, we test if the function TestVisibleTarget returns true. If it does, it goes on to execute the children, which are calling the functions Aim and Shoot
• If the test returns false, the If node returns Failure and the root then goes to the next child. This is a Sequence, which starts by executing its first child
• This calls the function Walk. It returns Success so that the Sequence sets the next child as active and executes it
• The Wait node executes. Because it has to wait for 5 seconds and was just called for the 1st time, it hasn't reached the wait time, so it returns Continue
• Because the Sequence receives a Continue state from its active child, it doesn't change the active child, so it starts from that child on the next Update
• Once the Wait node has been updated enough to reach its timer, it returns Success so that the sequence goes to the next child.

• Success: the sequence ticks the next child on the next frame.
• Failure: the sequence returns to the first child on the next frame.
• Continue: the sequence calls that node again on the next frame.

• If it returns true, it calls the current active child and return its state.
• Otherwise, it returns Failure without calling its children