[Add] Synaptic AI Pro

https://assetstore.unity.com/packages/tools/generative-ai/synaptic-ai-pro-natural-language-control-for-unity-336030

Assets/Synaptic AI Pro/Runtime/BehaviorTree/BTComposites.cs

@@ -0,0 +1,327 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace SynapticPro.BehaviorTree
+{
+    /// <summary>
+    /// Selector (OR) - Returns Success if ANY child succeeds
+    /// Tries children in order until one succeeds
+    /// </summary>
+    public class BTSelector : BTComposite
+    {
+        public BTSelector(string name = "Selector") : base(name) { }
+
+        public override BTStatus Tick()
+        {
+            for (int i = currentChildIndex; i < children.Count; i++)
+            {
+                var status = children[i].Tick();
+
+                switch (status)
+                {
+                    case BTStatus.Success:
+                        currentChildIndex = 0;
+                        IsRunning = false;
+                        return BTStatus.Success;
+
+                    case BTStatus.Running:
+                        currentChildIndex = i;
+                        IsRunning = true;
+                        return BTStatus.Running;
+
+                    case BTStatus.Failure:
+                        // Try next child
+                        continue;
+                }
+            }
+
+            // All children failed
+            currentChildIndex = 0;
+            IsRunning = false;
+            return BTStatus.Failure;
+        }
+    }
+
+    /// <summary>
+    /// Sequence (AND) - Returns Success only if ALL children succeed
+    /// Executes children in order, stops on first failure
+    /// </summary>
+    public class BTSequence : BTComposite
+    {
+        public BTSequence(string name = "Sequence") : base(name) { }
+
+        public override BTStatus Tick()
+        {
+            for (int i = currentChildIndex; i < children.Count; i++)
+            {
+                var status = children[i].Tick();
+
+                switch (status)
+                {
+                    case BTStatus.Success:
+                        // Continue to next child
+                        continue;
+
+                    case BTStatus.Running:
+                        currentChildIndex = i;
+                        IsRunning = true;
+                        return BTStatus.Running;
+
+                    case BTStatus.Failure:
+                        currentChildIndex = 0;
+                        IsRunning = false;
+                        return BTStatus.Failure;
+                }
+            }
+
+            // All children succeeded
+            currentChildIndex = 0;
+            IsRunning = false;
+            return BTStatus.Success;
+        }
+    }
+
+    /// <summary>
+    /// Parallel - Runs all children simultaneously
+    /// Returns based on policy (RequireAll or RequireOne)
+    /// </summary>
+    public class BTParallel : BTComposite
+    {
+        public enum Policy
+        {
+            RequireAll,  // Success only if ALL succeed
+            RequireOne   // Success if ANY succeeds
+        }
+
+        public Policy SuccessPolicy { get; set; } = Policy.RequireAll;
+        public Policy FailurePolicy { get; set; } = Policy.RequireOne;
+
+        private List<BTStatus> childStatuses = new List<BTStatus>();
+
+        public BTParallel(string name = "Parallel") : base(name) { }
+
+        public BTParallel(Policy successPolicy, Policy failurePolicy, string name = "Parallel") : base(name)
+        {
+            SuccessPolicy = successPolicy;
+            FailurePolicy = failurePolicy;
+        }
+
+        public override BTStatus Tick()
+        {
+            // Initialize status tracking
+            while (childStatuses.Count < children.Count)
+            {
+                childStatuses.Add(BTStatus.Running);
+            }
+
+            int successCount = 0;
+            int failureCount = 0;
+            int runningCount = 0;
+
+            for (int i = 0; i < children.Count; i++)
+            {
+                // Skip already completed children
+                if (childStatuses[i] != BTStatus.Running)
+                {
+                    if (childStatuses[i] == BTStatus.Success) successCount++;
+                    else failureCount++;
+                    continue;
+                }
+
+                var status = children[i].Tick();
+                childStatuses[i] = status;
+
+                switch (status)
+                {
+                    case BTStatus.Success:
+                        successCount++;
+                        break;
+                    case BTStatus.Failure:
+                        failureCount++;
+                        break;
+                    case BTStatus.Running:
+                        runningCount++;
+                        break;
+                }
+            }
+
+            // Check failure policy
+            if (FailurePolicy == Policy.RequireOne && failureCount > 0)
+            {
+                Reset();
+                return BTStatus.Failure;
+            }
+            if (FailurePolicy == Policy.RequireAll && failureCount == children.Count)
+            {
+                Reset();
+                return BTStatus.Failure;
+            }
+
+            // Check success policy
+            if (SuccessPolicy == Policy.RequireOne && successCount > 0)
+            {
+                Reset();
+                return BTStatus.Success;
+            }
+            if (SuccessPolicy == Policy.RequireAll && successCount == children.Count)
+            {
+                Reset();
+                return BTStatus.Success;
+            }
+
+            // Still running
+            if (runningCount > 0)
+            {
+                IsRunning = true;
+                return BTStatus.Running;
+            }
+
+            // Default to failure
+            Reset();
+            return BTStatus.Failure;
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            childStatuses.Clear();
+        }
+    }
+
+    /// <summary>
+    /// Random Selector - Randomly picks a child to execute
+    /// </summary>
+    public class BTRandomSelector : BTComposite
+    {
+        private List<int> shuffledIndices = new List<int>();
+        private int currentIndex = 0;
+
+        public BTRandomSelector(string name = "RandomSelector") : base(name) { }
+
+        public override BTStatus Tick()
+        {
+            // Shuffle on first tick
+            if (shuffledIndices.Count == 0)
+            {
+                ShuffleChildren();
+            }
+
+            for (int i = currentIndex; i < shuffledIndices.Count; i++)
+            {
+                var childIndex = shuffledIndices[i];
+                var status = children[childIndex].Tick();
+
+                switch (status)
+                {
+                    case BTStatus.Success:
+                        Reset();
+                        return BTStatus.Success;
+
+                    case BTStatus.Running:
+                        currentIndex = i;
+                        IsRunning = true;
+                        return BTStatus.Running;
+
+                    case BTStatus.Failure:
+                        continue;
+                }
+            }
+
+            Reset();
+            return BTStatus.Failure;
+        }
+
+        private void ShuffleChildren()
+        {
+            shuffledIndices.Clear();
+            for (int i = 0; i < children.Count; i++)
+            {
+                shuffledIndices.Add(i);
+            }
+
+            // Fisher-Yates shuffle
+            for (int i = shuffledIndices.Count - 1; i > 0; i--)
+            {
+                int j = Random.Range(0, i + 1);
+                var temp = shuffledIndices[i];
+                shuffledIndices[i] = shuffledIndices[j];
+                shuffledIndices[j] = temp;
+            }
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            shuffledIndices.Clear();
+            currentIndex = 0;
+        }
+    }
+
+    /// <summary>
+    /// Random Sequence - Executes children in random order
+    /// </summary>
+    public class BTRandomSequence : BTComposite
+    {
+        private List<int> shuffledIndices = new List<int>();
+        private int currentIndex = 0;
+
+        public BTRandomSequence(string name = "RandomSequence") : base(name) { }
+
+        public override BTStatus Tick()
+        {
+            // Shuffle on first tick
+            if (shuffledIndices.Count == 0)
+            {
+                ShuffleChildren();
+            }
+
+            for (int i = currentIndex; i < shuffledIndices.Count; i++)
+            {
+                var childIndex = shuffledIndices[i];
+                var status = children[childIndex].Tick();
+
+                switch (status)
+                {
+                    case BTStatus.Success:
+                        continue;
+
+                    case BTStatus.Running:
+                        currentIndex = i;
+                        IsRunning = true;
+                        return BTStatus.Running;
+
+                    case BTStatus.Failure:
+                        Reset();
+                        return BTStatus.Failure;
+                }
+            }
+
+            Reset();
+            return BTStatus.Success;
+        }
+
+        private void ShuffleChildren()
+        {
+            shuffledIndices.Clear();
+            for (int i = 0; i < children.Count; i++)
+            {
+                shuffledIndices.Add(i);
+            }
+
+            for (int i = shuffledIndices.Count - 1; i > 0; i--)
+            {
+                int j = Random.Range(0, i + 1);
+                var temp = shuffledIndices[i];
+                shuffledIndices[i] = shuffledIndices[j];
+                shuffledIndices[j] = temp;
+            }
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            shuffledIndices.Clear();
+            currentIndex = 0;
+        }
+    }
+}