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)); } }