Possible to inject to and read from ComponentData from the nodes instead of the root?

[KontosTwo]

I'm going for an architecture that decouples behavior tree flow from the actions each node performs. This is done by grouping each action (Walk, Attack, Evade, Flank, etc...) into this structure

The Behavior Unit Entity is a Sequence Node, the Start and End Entities are barebones Nodes that write to the Behavior's Entity IComponentData. Custom IComponentData that influence System processing go into the Behavior Entity. In other words, Behavior Unit, Start, and End do all the Behavior Tree stuff, while Behavior does all the action processing using the action's bare minimum required components. This should theoretically avoid using God Entities which would have every single action-related component in the game, but is thwarted by the fact that every time this happens:

where the Blackboard fetches a DataRef, a new instance of that IComponentData is injected into the behavior tree root, instead of the current node. The result is this:

while the nodes themselves have their own copy that they never write to because of this code:

Basically, no matter what I do, all IComponentData used in Tick are injected into the root Entity instead of the current node. If I proceed with this structure, then the root Entity will have dozens upon dozens of different components in different combinations. This would not use chunk space efficiently, and iteration would be clunky and slow. On the other hand, if the IComponentData is injected into the nodes instead, there would be a few, homogenous archetypes with well-utilized chunks, which is ideal.

I understand that the concept of a "blackboard" is that it holds all state, and the blackboard seems to be stored in the root. This would mean that my idea violates the design philosophy of EntitiesBT where Nodes are stateless. Still, I believe my game would benefit from node-specific component storage. Is there a way to have the IComponentData reside in the Node that uses it, instead of the root Entity? If a feature from you is not possible, and I have to do some code wrangling, that's fine as long as it's possible.

[KontosTwo]

Also, here's how the data from EntitiesBT interact with the rest of the ECS code

using EntitiesBT.Entities;
using Unity.Burst.CompilerServices;
using Unity.Entities;
using UnityEngine;

namespace Collapse
{
    [UpdateBefore(typeof(VirtualMachineSystem))]
    public sealed class BehaviorSystem : SystemBase
    {
        protected override void OnUpdate()
        {
            var startWriter = GetComponentDataFromEntity<BehaviorStartSyncComponent>(false);

            Entities
                .WithNativeDisableParallelForRestriction(startWriter)
                //.WithChangeFilter<BehaviorStartComponent>()
                .ForEach((ref BehaviorStartComponent start, in BehaviorStartSyncRefComponent _ref) =>
                {
                    if (Hint.Unlikely(start.started))
                    {
                        Debug.Log("starting");
                        startWriter[_ref.entity] = new BehaviorStartSyncComponent
                        {
                            started = true
                        };
                        start.started = false;
                    }
                })
                .WithBurst()
                .ScheduleParallel();

            var endWriter = GetComponentDataFromEntity<BehaviorEndComponent>(false);

            Entities
                .WithNativeDisableParallelForRestriction(endWriter)
                //.WithChangeFilter<BehaviorEndSyncComponent>()
                .ForEach((ref BehaviorEndSyncComponent end, in BehaviorEndRefComponent _ref) =>
                {
                    if (Hint.Unlikely(end.completed))
                    {
                        Debug.Log("writing back");
                        endWriter[_ref.entity] = new BehaviorEndComponent
                        {
                            completed = end.completed,
                            succeeded = end.succeeded
                        };
                        end.completed = false;
                        end.succeeded = false;
                    }
                })
                .WithBurst()
                .ScheduleParallel();


            // The following job simulates an action that finishes instantly. Most actions will take several frames to complete and then set end.completed to true
            Entities
                //.WithChangeFilter<BehaviorStartSyncComponent>()
                .ForEach((ref BehaviorStartSyncComponent start, ref BehaviorEndSyncComponent end) =>
                {
                    if (Hint.Unlikely(start.started))
                    {
                        Debug.Log("completing");
                        start.started = false;
                        end.completed = true;
                        end.succeeded = true;
                    }
                })
                .WithBurst()
                .ScheduleParallel();
        }
    }
}

[quabug]

IBlackboard, and related functions like component injection or entity query generation, is designed to be work on single Entity, you have to use EntityManager and Entity directly to access IComponentData on other Entitys.

Take this node as example, you must have both EntityManager and Entity to access component on Entity.

[BehaviorNode("1C695088-A8BE-43C4-B145-6E617825B39A")]
public struct AccessEntity : INodeData
{
    public NodeState Tick<TNodeBlob, TBlackboard>(int index, ref TNodeBlob blob, ref TBlackboard bb)
        where TNodeBlob : struct, INodeBlob
        where TBlackboard : struct, IBlackboard
    {
        var em = bb.GetObject<EntityManagerComponent>().Value;
        var entity = bb.GetDynamicBufferUnsafeRO<Child>()[0].Value;
        var value = em.GetComponentData<IntComponent>(entity).Value;
        return NodeState.Success;
    }
}

public struct IntComponent : IComponentData
{
    public int Value;
}

public class EntityManagerComponent : IComponentData
{
    public EntityManager Value;
}

public class EntityManagerComponentAuthoring : MonoBehaviour, IConvertGameObjectToEntity
{
    public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
    {
        dstManager.AddComponentData(entity, new EntityManagerComponent { Value = World.DefaultGameObjectInjectionWorld.EntityManager });
    }
}

Full Sample

You can also access component in job as long as you have Chunk and ChunkIndex, but you have to handle EntityQuery somehow.

There's tedious work to do If you are intend to make bb.GetData<SomeComponent>() accessing on its own entity rather than root.

Maybe I could write a quick/dirty example of this feature, if you still want to access node entity by using GetData or GetDataRef.

[KontosTwo]

That's very helpful!

You can also access component in job as long as you have Chunk and ChunkIndex, but you have to handle EntityQuery somehow.

This, along with your example, answers my part of my question. While the Node's entity can be injected into the Node's Tick() function, and an EntityManager is used to manipulate the Node entity's components, the entire thing is not able to run in a job. I'm thinking about:

1. Have a class IComponentData store the current frame's ComponentDataFromEntity on the root Node
2. Inject the ComponentDataFromEntity into the root node from a System
3. Obtain the ComponentDataFromEntity in the node's Tick() method through bb.GetObject()
4. Write to or read from the component

Maybe I could write a quick/dirty example of this feature, if you still want to access node entity by using GetData or GetDataRef.

I would be extremely grateful for this. Just keep in mind that it may not benefit users other than me unless they take advantage of the architecture I'm using. I could start a PR for adding a section at the bottom of the README called "Design Suggestions" if you'd like.

[quabug]

1. Have a class IComponentData store the current frame's ComponentDataFromEntity on the root Node
2. Inject the ComponentDataFromEntity into the root node from a System
3. Obtain the ComponentDataFromEntity in the node's Tick() method through bb.GetObject()
4. Write to or read from the component

It is hard to predicate which ComponentDataFromEntitys should be inject into root before Tick(), the realistic way would be like 1. make it running on main thread, or 2. combine all possible entity query (type of component data) into one big job dependencies and make it safe to access any necessary component from any entity.

Another problem is how to connect behavior node to entity instance, or how to find certain entity by node index. A naive solution is add a component data, contains and index all entities, on root and store a map of [node index->entity index].

I'll try to finger this out later this week.

I would be extremely grateful for this. Just keep in mind that it may not benefit users other than me unless they take advantage of the architecture I'm using. I could start a PR for adding a section at the bottom of the README called "Design Suggestions" if you'd like.

I'd like any contribute from the community, and appreciate if you have time to write such section once this feature/idea have concrete implement.

[quabug]

@KontosTwo

patch.txt

Here's a patch file of accessing node entity in blackboard, you can apply it by git apply patch.txt.
It is a quick and dirty implementation of such feature for demonstration only.

[KontosTwo]

Sorry @quabug , I did not have Github notifications set up until now. I just finished trying out your changes and they look great. Here are the results:

Here's the Node code

[BehaviorNode("F5C2EE7E-690A-4B5C-9489-FB362C949193")] // must add this attribute to indicate a class is a `BehaviorNode`
public struct EntityMoveNode : INodeData
{
    public float3 Velocity; // node data saved in `INodeBlob`

    public NodeState Tick<TNodeBlob, TBlackboard>(int index, ref TNodeBlob blob, ref TBlackboard bb)
        where TNodeBlob : struct, INodeBlob
        where TBlackboard : struct, IBlackboard
    { // access and modify node data
        ref var translation = ref bb.GetDataRef<Translation>(); // get blackboard data by ref (read/write)
        ref var test = ref bb.GetDataRef<EntityCustom>();
        Debug.Log(test.test);
        return NodeState.Running;
    }

    public void Reset<TNodeBlob, TBlackboard>(int index, ref TNodeBlob blob, ref TBlackboard bb)
        where TNodeBlob : struct, INodeBlob
        where TBlackboard : struct, IBlackboard
    { }

}

// builder and editor part of node
public class EntityMove : BTNode<EntityMoveNode>
{
    public Vector3 Velocity;

    protected override void Build(ref EntityMoveNode data, BlobBuilder _, ITreeNode<INodeDataBuilder>[] __)
    {
        // set `NodeData` here
        data.Velocity = Velocity;
    }
}

public struct EntityCustom : IComponentData
{
    public float test;
}

and here's the Authoring to inject EntityCustom into the node

using System.Collections;
using System.Collections.Generic;
using Unity.Entities;
using UnityEngine;

public class CustomAuthoring : MonoBehaviour, IConvertGameObjectToEntity
{


    public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
    {
        dstManager.AddComponentData(entity, new EntityCustom
        {
            test = 5
        });
    }
}

This is being printed upon run

So the Entity's component, not a blackboard injected component, is being run. My only gripe is that this requires that you "register" each Node whose entity stores all referenced data like so

Perhaps you can automatically grab the Nodes with an annotation like
[LocalBlackboard] and then have the Behavior Tree Root search the root gameobject for nodes with this annnotation?

In addition, attempting to force the job to run on the main thread + Convert And Destroy is not supported yet, throwing NotImplementedException. This seems to be intentional, due to these lines

public void SetNodeEntityIndex(int nodeEntityIndex)
         {
             throw new NotImplementedException();
         }

in GameObjectWithoutEntity.

All in all, this is a great update. Are you planning on including this in the main EntitiesBT release soon? If so, I can write some documentation on how to take advantage of this feature to reduce chunk usage

[quabug]

Perhaps you can automatically grab the Nodes with an annotation like
[LocalBlackboard] and then have the Behavior Tree Root search the root gameobject for nodes with this annnotation?

The problem is BTNode is not the only way to build runtime behavior tree, so it is not possible to predicate which Entity should be bind to the INodeData. Maybe make [LocalBlackboard] only available for MonoBehavior builder?

Are you planning on including this in the main EntitiesBT release soon?

I am not planing to release this at the moment since there's still some issues need to be solved:

1. As you already noticed, this requires that you "register" each Node whose entity stores all referenced data, and it is error-prone to manually assign Entity to INodeData.
2. How to make it run on Job safely?
3. How to use a custom IBlackboard instead of default one? a custom VirtualMachineSystem?

After all I'd like to add this feature as separate package if possible.