public PickRandomLocationExecutable Init(IBlackboardComponent blackboard, HiraBlackboardKey key, string locationName)
{
_blackboard = blackboard;
_key = key.Index;
_locationName = locationName;
return(this);
}
public RotateToExecutable Init(Transform target, IBlackboardComponent blackboard, HiraBlackboardKey locationKey)
{
_target = target;
_blackboard = blackboard;
_locationKey = locationKey;
return(this);
}
public BottomLayerRunner(
IParentLayerRunner parent,
MonoBehaviour coroutineRunner,
IBlackboardComponent blackboard,
IPlannerDomain domain,
byte layerIndex,
float maxFScore,
RawBlackboardArrayWrapper plannerDatasets,
byte maxPlanLength)
{
Parent = parent;
_coroutineRunner = coroutineRunner;
_blackboard = blackboard;
_domain = domain;
_layerIndex = layerIndex;
_maxFScore = maxFScore;
_plannerDatasets = plannerDatasets;
_result.First = new PlannerResult(maxPlanLength, Allocator.Persistent)
{
Count = 0
};
_result.Second = new PlannerResult(maxPlanLength, Allocator.Persistent)
{
Count = 0
};
}
public static void ApplyTo(this IBlackboardEffector[] effectors, IBlackboardComponent blackboard)
{
foreach (var effector in effectors)
{
effector.ApplyTo(blackboard);
}
}
public TaskRunner(HiraComponentContainer target, IBlackboardComponent blackboard, IPlannerDomain domain, Action <bool> onPlanRunnerFinished)
{
_domain = domain;
_target = target;
_blackboard = blackboard;
_executionQueue = ExecutionQueue.Create();
_serviceRunner = ServiceRunner.Create();
_onPlanRunnerFinished = onPlanRunnerFinished;
}
public Executable GetExecutable(HiraComponentContainer target, IBlackboardComponent blackboard)
{
if (target is IContainsComponent <NavMeshAgent> navigableTarget && navigableTarget.Component != null)
{
return(GenericPool <StaticMoveToExecutable> .Retrieve().Init(navigableTarget.Component, blackboard, targetPosition, followTarget, speed, tolerance));
}
return(AutoFailExecutable.INSTANCE);
}
public Executable GetExecutable(HiraComponentContainer target, IBlackboardComponent blackboard)
{
if (target is IContainsComponent <AgentAnimator> animatedTarget)
{
return(GenericPool <KickExecutable> .Retrieve().Init(animatedTarget.Component));
}
return(AutoFailExecutable.INSTANCE);
}
public override unsafe void DrawEditor(void *data, IBlackboardComponent blackboard)
{
var value = *(byte *)data;
var output = UnityEditor.EditorGUILayout.Toggle(name, (value).ToBoolean()).ToByte();
if (output != value)
{
MainThreadDispatcher.Schedule(() => blackboard.SetValue(Index, output));
}
}
public override unsafe void DrawEditor(void *data, IBlackboardComponent blackboard)
{
var value = *(int *)data;
var output = UnityEditor.EditorGUILayout.DelayedIntField(name, value);
if (value != output)
{
MainThreadDispatcher.Schedule(() => blackboard.SetValue(Index, output));
}
}
public StaticMoveToExecutable Init(NavMeshAgent navMeshAgent, IBlackboardComponent blackboard, HiraBlackboardKey targetPositionKey, bool followTarget, float speed, float tolerance)
{
_navMeshAgent = navMeshAgent;
_blackboard = blackboard;
_targetPositionKey = targetPositionKey.Index;
_followTarget = followTarget;
_speed = speed;
_tolerance = tolerance;
return(this);
}
public bool IsValidOn(IBlackboardComponent blackboard)
{
var currentX = blackboard.GetValue <float>(key.Index);
var currentY = blackboard.GetValue <float>((ushort)(key.Index + sizeof(float)));
var currentZ = blackboard.GetValue <float>((ushort)(key.Index + sizeof(float) + sizeof(float)));
return(invert != ((Mathf.Abs(currentX - value.x) <= tolerance.x) &&
(Mathf.Abs(currentY - value.y) <= tolerance.y) &&
(Mathf.Abs(currentZ - value.z) <= tolerance.z)));
}
public override unsafe void DrawEditor(void *data, IBlackboardComponent blackboard)
{
var value = *(float *)data;
var output = UnityEditor.EditorGUILayout.DelayedFloatField(name, value);
// ReSharper disable once CompareOfFloatsByEqualityOperator
if (output != value)
{
MainThreadDispatcher.Schedule(() => blackboard.SetValue(Index, output));
}
}
public override unsafe void DrawEditor(void *data, IBlackboardComponent blackboard)
{
var valuePtr = (float *)data;
var output = UnityEditor.EditorGUILayout.Vector3Field(name, new Vector3(valuePtr[0], valuePtr[1], valuePtr[2]));
// ReSharper disable thrice CompareOfFloatsByEqualityOperator
if (output.x != valuePtr[0] || output.y != valuePtr[1] || output.z != valuePtr[2])
{
MainThreadDispatcher.Schedule(() => blackboard.SetValue(Index, output));
}
}
public static bool IsValidOn(this IBlackboardDecorator[] decorators, IBlackboardComponent blackboard)
{
foreach (var decorator in decorators)
{
if (!decorator.IsValidOn(blackboard))
{
return(false);
}
}
return(true);
}
public override ExecutionStatus Execute(float deltaTime)
{
ExecutionStatus result;
if (RandomLocation.TryGet(_locationName, out _current))
{
_blackboard.SetValue <Vector3>(_key, _current.transform.position);
result = ExecutionStatus.Succeeded;
}
else
{
result = ExecutionStatus.Failed;
}
_blackboard = null;
return(result);
}
public TopLayerRunner(
MonoBehaviour coroutineRunner,
IBlackboardComponent blackboard,
IPlannerDomain domain,
RawBlackboardArrayWrapper plannerDatasets)
{
_coroutineRunner = coroutineRunner;
_blackboard = blackboard;
_domain = domain;
_plannerDatasets = plannerDatasets;
_result.First = new PlannerResult(1, Allocator.Persistent)
{
Count = 1, [0] = byte.MaxValue
};
_result.Second = new PlannerResult(1, Allocator.Persistent)
{
Count = 1, [0] = byte.MaxValue
};
}
public bool IsValidOn(IBlackboardComponent blackboard) => blackboard.GetValue <byte>(key.Index) == value.ToByte();
public void OnReturn()
{
_target = null;
_blackboard = null;
_locationKey = null;
}
public unsafe void CopyFirstFrom(IBlackboardComponent blackboard)
{
var data = (byte *)_container.GetUnsafePtr();
UnsafeUtility.MemCpy(data, blackboard.Data.GetUnsafeReadOnlyPtr(), _size);
}
public Executable GetExecutable(HiraComponentContainer target, IBlackboardComponent blackboard)
{
return(GenericPool <RotateToExecutable> .Retrieve().Init(target.transform, blackboard, location));
}
public bool IsValidOn(IBlackboardComponent blackboard) => invert != (Mathf.Abs(blackboard.GetValue <float>(key.Index) - value) <= tolerance);
public void ApplyTo(IBlackboardComponent blackboard) => blackboard.SetValue <int>(key.Index, blackboard.GetValue <int>(key.Index) + blackboard.GetValue <int>(toAdd.Index));
public void ApplyTo(IBlackboardComponent blackboard)
{
blackboard.SetValue <float>(key.Index, value.x);
blackboard.SetValue <float>((ushort)(key.Index + sizeof(float)), value.y);
blackboard.SetValue <float>((ushort)(key.Index + sizeof(float) + sizeof(float)), value.z);
}
public float CalculateScore(IBlackboardComponent blackboard) => score;
public Executable GetExecutable(HiraComponentContainer target, IBlackboardComponent blackboard) => GenericPool <PickRandomLocationExecutable> .Retrieve().Init(blackboard, storeIn, location);
public abstract unsafe void DrawEditor(void *data, IBlackboardComponent blackboard);
public float CalculateScore(IBlackboardComponent blackboard) => IsValidOn(blackboard) ? score : 0f;
public static float CalculateScore(this IBlackboardScoreCalculator[] scoreCalculators, IBlackboardComponent blackboard)
{
var score = 0f;
foreach (var calculator in scoreCalculators)
{
score += calculator.CalculateScore(blackboard);
}
return(score);
}
public void ApplyTo(IBlackboardComponent blackboard) => blackboard.SetValue <byte>(key.Index, (byte)(1 - blackboard.GetValue <byte>(key.Index)));
public void Populate(ExecutionQueue executionQueue, ServiceRunner serviceRunner, HiraComponentContainer target, IBlackboardComponent blackboard)
{
if (Collection4.Length == 0)
{
executionQueue.Append(AutoSucceedExecutable.INSTANCE);
}
foreach (var provider in Collection4)
{
executionQueue.Append(provider.GetExecutable(target, blackboard));
}
foreach (var serviceProvider in Collection5)
{
serviceRunner.Append(serviceProvider.GetService(target, blackboard));
}
}