Upload 64 files

data/2.5D Physics.txt

@@ -0,0 +1,31 @@
+Introduction
+Using 2.5D Physics you are able to add Height, or thickness depending on your perspective, while still benefiting from most performance advantages available in 2D. N.B.: Use Vertical Transform has to be manually enabled in the SimulationConfig asset's Physics settings.
+
+Back To Top
+ 
+
+2.5D Physics With Vertical Data
+StaticCollider2D can have 'thickness' in the 3rd dimension using Quantum's 2.5D physics; simply set the Height:
+
+Adding Height to a Static Collider
+Adding Height to a Static Collider.
+For Entities, just add the Transform2DVertical component and set its Height and Position. On a Quantum XZ-oriented game, this adds height on the Y axis, for example. N.B.: Transform2DVertical requires the Transform2D component.
+
+var transform2dVertical = new Transform2DVertical();
+transform2dVertical.Height = FP._1;
+transform2dVertical.Position = FP._1;
+
+f.Set(entity, transform2dVertical);
+Adding Height to an Entity Prototype
+Adding Height to an Entity Prototype.
+If entities or statics have a 3rd dimension, the physics engine will take into consideration when solving collisions. This allows for 'aerial' entities to fly over 'ground-based' ones, etc.
+
+Back To Top
+ 
+
+Physics Engine Implications
+
+Entity Separation
+Important: When a collision is detected, the collision solver does not use the extra dimension information. This can result in entity bounce when separation is performed on the basic 2D plane of the physics engine.
+
+It is possible to simulate 3-dimensional gravity by manually applying speed and forces directly on Transform2DVertical.Position. The physics engine will use that information only for collision detection though.

data/AIAction.cs

@@ -0,0 +1,14 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	public abstract unsafe partial class AIAction
+	{
+		public string Label;
+		public const int NEXT_ACTION_DEFAULT = -1;
+
+		public abstract void Update(Frame frame, EntityRef entity);
+		public virtual int NextAction(Frame frame, EntityRef entity) { return NEXT_ACTION_DEFAULT; }
+	}
+}

data/AIAction.qtn

@@ -0,0 +1 @@
+asset AIAction;

data/AIBlackboard.cs

@@ -0,0 +1,69 @@
+using Photon.Deterministic;
+using System;
+using System.Collections.Generic;
+
+namespace Quantum
+{
+	public unsafe partial class AIBlackboard
+	{
+		public AIBlackboardEntry[] Entries;
+
+		[NonSerialized] public Dictionary<String, Int32> Map;
+
+		public override void Loaded(IResourceManager resourceManager, Native.Allocator allocator)
+		{
+			base.Loaded(resourceManager, allocator);
+
+			Map = new Dictionary<string, Int32>();
+
+			for (Int32 i = 0; i < Entries.Length; i++)
+			{
+				Map.Add(Entries[i].Key.Key, i);
+			}
+		}
+
+		public Int32 GetEntryID(string key)
+		{
+			Assert.Check(string.IsNullOrEmpty(key) == false, "The Key cannot be empty or null.");
+			Assert.Check(Map.ContainsKey(key) == true, $"Key {0} not present in the Blackboard", key);
+
+			return Map[key];
+		}
+
+		public bool TryGetEntryID(string key, out Int32 id)
+		{
+			return Map.TryGetValue(key, out id);
+		}
+
+		public string GetEntryName(Int32 id)
+		{
+			return Entries[id].Key.Key;
+		}
+
+		public bool HasEntry(string key)
+		{
+			for (int i = 0; i < Entries.Length; i++)
+			{
+				if (Entries[i].Key.Key == key)
+				{
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		public AIBlackboardEntry GetEntry(string key)
+		{
+			for (int i = 0; i < Entries.Length; i++)
+			{
+				if (Entries[i].Key.Key == key)
+				{
+					return Entries[i];
+				}
+			}
+
+			return default;
+		}
+	}
+}

data/AIBlackboardComponent.cs

@@ -0,0 +1,290 @@
+using Photon.Deterministic;
+using System;
+using Quantum.Collections;
+
+namespace Quantum
+{
+	public unsafe partial struct AIBlackboardComponent
+	{
+		#region Init/Free
+		public void InitializeBlackboardComponent(Frame frame, AIBlackboard blackboardAsset)
+		{
+			Board = blackboardAsset;
+
+			var assetEntries = blackboardAsset.Entries;
+
+			if (Entries.Ptr != default)
+			{
+				FreeBlackboardComponent(frame);
+			}
+
+			QList<BlackboardEntry> entriesList = frame.AllocateList<BlackboardEntry>(blackboardAsset.Entries.Length);
+
+			for (int i = 0; i < assetEntries.Length; i++)
+			{
+				BlackboardValue newValue = CreateValueFromEntry(assetEntries[i]);
+				entriesList.Add(new BlackboardEntry { Value = newValue });
+				//entriesList.Add(newValue);
+			}
+
+			Entries = entriesList;
+		}
+
+		public void FreeBlackboardComponent(Frame frame)
+		{
+			if (Entries.Ptr != default)
+			{
+				frame.FreeList(Entries);
+				Entries = default;
+			}
+		}
+
+		private BlackboardValue CreateValueFromEntry(AIBlackboardEntry entry)
+		{
+			BlackboardValue newValue = new BlackboardValue();
+
+			if (entry.Type == AIBlackboardValueType.Boolean)
+			{
+				*newValue.BooleanValue = default;
+			}
+
+			if (entry.Type == AIBlackboardValueType.Byte)
+			{
+				*newValue.ByteValue = default;
+			}
+
+			if (entry.Type == AIBlackboardValueType.Integer)
+			{
+				*newValue.IntegerValue = default;
+			}
+
+			if (entry.Type == AIBlackboardValueType.FP)
+			{
+				*newValue.FPValue = default;
+			}
+
+			if (entry.Type == AIBlackboardValueType.Vector2)
+			{
+				*newValue.FPVector2Value = default;
+			}
+
+			if (entry.Type == AIBlackboardValueType.Vector3)
+			{
+				*newValue.FPVector3Value = default;
+			}
+
+			if (entry.Type == AIBlackboardValueType.EntityRef)
+			{
+				*newValue.EntityRefValue = default;
+			}
+
+			return newValue;
+		}
+		#endregion
+
+		#region Getters
+		public QBoolean GetBoolean(Frame frame, string key)
+		{
+			var bbValue = GetBlackboardValue(frame, key);
+			return *bbValue.BooleanValue;
+		}
+
+		public byte GetByte(Frame frame, string key)
+		{
+			var bbValue = GetBlackboardValue(frame, key);
+			return *bbValue.ByteValue;
+		}
+
+		public Int32 GetInteger(Frame frame, string key)
+		{
+			var bbValue = GetBlackboardValue(frame, key);
+			return *bbValue.IntegerValue;
+		}
+
+		public FP GetFP(Frame frame, string key)
+		{
+			var bbValue = GetBlackboardValue(frame, key);
+			return *bbValue.FPValue;
+		}
+
+		public FPVector2 GetVector2(Frame frame, string key)
+		{
+			var bbValue = GetBlackboardValue(frame, key);
+			return *bbValue.FPVector2Value;
+		}
+
+		public FPVector3 GetVector3(Frame frame, string key)
+		{
+			var bbValue = GetBlackboardValue(frame, key);
+			return *bbValue.FPVector3Value;
+		}
+
+		public EntityRef GetEntityRef(Frame frame, string key)
+		{
+			var bbValue = GetBlackboardValue(frame, key);
+			return *bbValue.EntityRefValue;
+		}
+		#endregion
+
+		#region Setters
+		public BlackboardEntry* Set(Frame frame, string key, QBoolean value)
+		{
+			QList<BlackboardEntry> valueList = frame.ResolveList(Entries);
+			var ID = GetID(frame, key);
+			*valueList.GetPointer(ID)->Value.BooleanValue = value;
+
+			return valueList.GetPointer(ID);
+		}
+
+		public BlackboardEntry* Set(Frame frame, string key, byte value)
+		{
+			QList<BlackboardEntry> valueList = frame.ResolveList(Entries);
+			var ID = GetID(frame, key);
+			*valueList.GetPointer(ID)->Value.ByteValue = value;
+
+			return valueList.GetPointer(ID);
+		}
+
+		public BlackboardEntry* Set(Frame frame, string key, Int32 value)
+		{
+			QList<BlackboardEntry> valueList = frame.ResolveList(Entries);
+			var ID = GetID(frame, key);
+			*valueList.GetPointer(ID)->Value.IntegerValue = value;
+
+			return valueList.GetPointer(ID);
+		}
+
+		public BlackboardEntry* Set(Frame frame, string key, FP value)
+		{
+			QList<BlackboardEntry> valueList = frame.ResolveList(Entries);
+			var ID = GetID(frame, key);
+			*valueList.GetPointer(ID)->Value.FPValue = value;
+
+			return valueList.GetPointer(ID);
+		}
+
+		public BlackboardEntry* Set(Frame frame, string key, FPVector2 value)
+		{
+			QList<BlackboardEntry> valueList = frame.ResolveList(Entries);
+			var ID = GetID(frame, key);
+			*valueList.GetPointer(ID)->Value.FPVector2Value = value;
+
+			return valueList.GetPointer(ID);
+		}
+
+		public BlackboardEntry* Set(Frame frame, string key, FPVector3 value)
+		{
+			QList<BlackboardEntry> valueList = frame.ResolveList(Entries);
+			var ID = GetID(frame, key);
+			*valueList.GetPointer(ID)->Value.FPVector3Value = value;
+
+			return valueList.GetPointer(ID);
+
+		}
+
+		public BlackboardEntry* Set(Frame frame, string key, EntityRef value)
+		{
+			QList<BlackboardEntry> valueList = frame.ResolveList(Entries);
+			var ID = GetID(frame, key);
+			*valueList.GetPointer(ID)->Value.EntityRefValue = value;
+
+			return valueList.GetPointer(ID);
+		}
+		#endregion
+
+		#region Helpers
+		public BlackboardEntry* GetBlackboardEntry(Frame frame, string key)
+		{
+			var bbAsset = frame.FindAsset<AIBlackboard>(Board.Id);
+			var ID = bbAsset.GetEntryID(key);
+			var values = frame.ResolveList(Entries);
+			return values.GetPointer(ID);
+		}
+
+		public BlackboardValue GetBlackboardValue(Frame frame, string key)
+		{
+			Assert.Check(string.IsNullOrEmpty(key) == false, "The Key cannot be empty or null.");
+
+			var bbAsset = frame.FindAsset<AIBlackboard>(Board.Id);
+			var ID = bbAsset.GetEntryID(key);
+			var values = frame.ResolveList(Entries);
+
+			return values[ID].Value;
+		}
+
+		public Int32 GetID(Frame frame, string key)
+		{
+			Assert.Check(string.IsNullOrEmpty(key) == false, "The Key cannot be empty or null.");
+
+			var bbAsset = frame.FindAsset<AIBlackboard>(Board.Id);
+			var ID = bbAsset.GetEntryID(key);
+
+			return ID;
+		}
+
+		public bool HasEntry(Frame frame, string key)
+		{
+			var boardAsset = frame.FindAsset<AIBlackboard>(Board.Id);
+			return boardAsset.HasEntry(key);
+		}
+		#endregion
+
+		#region BT Specific
+		public void RegisterReactiveDecorator(Frame frame, string key, BTDecorator decorator)
+		{
+			var blackboardEntry = GetBlackboardEntry(frame, key);
+
+			QList<AssetRefBTDecorator> reactiveDecorators;
+			if (blackboardEntry->ReactiveDecorators.Ptr == default)
+			{
+				reactiveDecorators = frame.AllocateList<AssetRefBTDecorator>();
+			}
+			else
+			{
+				reactiveDecorators = frame.ResolveList<AssetRefBTDecorator>(blackboardEntry->ReactiveDecorators);
+			}
+			reactiveDecorators.Add(decorator);
+
+			blackboardEntry->ReactiveDecorators = reactiveDecorators;
+		}
+
+		public void UnregisterReactiveDecorator(Frame frame, string key, BTDecorator decorator)
+		{
+			var blackboardEntry = GetBlackboardEntry(frame, key);
+
+			if (blackboardEntry->ReactiveDecorators.Ptr != default)
+			{
+				QList<AssetRefBTDecorator> reactiveDecorators = frame.ResolveList<AssetRefBTDecorator>(blackboardEntry->ReactiveDecorators);
+				reactiveDecorators.Remove(decorator);
+				blackboardEntry->ReactiveDecorators = reactiveDecorators;
+			}
+		}
+		#endregion
+
+		#region Debug
+		public void Dump(Frame frame)
+		{
+			string dumpText = "";
+			var bbAsset = frame.FindAsset<AIBlackboard>(Board.Id);
+			dumpText += "Blackboard Path and ID: " + bbAsset.Path + "  |  " + Board.Id.Value;
+
+			var valuesList = frame.ResolveList(Entries);
+			for (int i = 0; i < valuesList.Count; i++)
+			{
+				string value = "NONE";
+				if (valuesList[i].Value.Field == BlackboardValue.BOOLEANVALUE) value = valuesList[i].Value.BooleanValue->Value.ToString();
+				if (valuesList[i].Value.Field == BlackboardValue.BYTEVALUE) value = valuesList[i].Value.ByteValue->ToString();
+				if (valuesList[i].Value.Field == BlackboardValue.INTEGERVALUE) value = valuesList[i].Value.IntegerValue->ToString();
+				if (valuesList[i].Value.Field == BlackboardValue.FPVALUE) value = valuesList[i].Value.FPValue->ToString();
+				if (valuesList[i].Value.Field == BlackboardValue.FPVECTOR2VALUE) value = valuesList[i].Value.FPVector2Value->ToString();
+				if (valuesList[i].Value.Field == BlackboardValue.FPVECTOR3VALUE) value = valuesList[i].Value.FPVector3Value->ToString();
+				if (valuesList[i].Value.Field == BlackboardValue.ENTITYREFVALUE) value = valuesList[i].Value.EntityRefValue->ToString();
+
+				dumpText += "\nName: " + bbAsset.GetEntryName(i) + ", Value: " + value;
+			}
+
+			Log.Info(dumpText);
+		}
+		#endregion
+	}
+}

data/AIBlackboardEntry.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Quantum
+{
+	// This struct is stored on the blackboard asset
+	// It is NOT the one used on the Blackboard component
+	[Serializable]
+	public struct AIBlackboardEntry
+	{
+		public AIBlackboardValueType Type;
+		public AIBlackboardValueKey Key;
+	}
+}

data/AIBlackboardInitializer.cs

@@ -0,0 +1,87 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	public unsafe partial class AIBlackboardInitializer
+	{
+		[Serializable]
+		public struct AIBlackboardInitialValue
+		{
+			public Boolean AsBoolean;
+			public Byte AsByte;
+			public Int32 AsInteger;
+			public FP AsFP;
+			public FPVector2 AsFPVector2;
+			public FPVector3 AsFPVector3;
+			public EntityRef AsEntityRef;
+		}
+
+		[Serializable]
+		public struct AIBlackboardInitialValueEntry
+		{
+			public string Key;
+			public AIBlackboardInitialValue Value;
+		}
+
+		public bool ReportMissingEntries = true;
+
+		public AssetRefAIBlackboard AIBlackboard;
+		public AIBlackboardInitialValueEntry[] InitialValues;
+
+
+		public unsafe static void InitializeBlackboard(Frame frame, AIBlackboardComponent* blackboard, AIBlackboardInitializer blackboardInitializer, AIBlackboardInitialValueEntry[] blackboardOverrides = null)
+		{
+			AIBlackboard board = frame.FindAsset<AIBlackboard>(blackboardInitializer.AIBlackboard.Id);
+
+			blackboard->InitializeBlackboardComponent(frame, board);
+
+			ApplyEntries(frame, blackboard, blackboardInitializer, blackboardInitializer.InitialValues);
+			ApplyEntries(frame, blackboard, blackboardInitializer, blackboardOverrides);
+		}
+
+		public unsafe static void ApplyEntries(Frame frame, AIBlackboardComponent* blackboard, AIBlackboardInitializer blackboardInitializer, AIBlackboardInitialValueEntry[] values)
+		{
+			if (values == null) return;
+
+			for (int i = 0; i < values.Length; i++)
+			{
+				string key = values[i].Key;
+				if (blackboard->HasEntry(frame, key) == false)
+				{
+					if (blackboardInitializer.ReportMissingEntries)
+					{
+						Quantum.Log.Warn($"Blackboard {blackboard->Board} does not have an entry with a key called '{key}'");
+					}
+					continue;
+				}
+
+				BlackboardValue value = blackboard->GetBlackboardValue(frame, key);
+				switch (value.Field)
+				{
+					case BlackboardValue.BOOLEANVALUE:
+						blackboard->Set(frame, key, values[i].Value.AsBoolean);
+						break;
+					case BlackboardValue.BYTEVALUE:
+						blackboard->Set(frame, key, values[i].Value.AsByte);
+						break;
+					case BlackboardValue.ENTITYREFVALUE:
+						blackboard->Set(frame, key, values[i].Value.AsEntityRef);
+						break;
+					case BlackboardValue.FPVALUE:
+						blackboard->Set(frame, key, values[i].Value.AsFP);
+						break;
+					case BlackboardValue.INTEGERVALUE:
+						blackboard->Set(frame, key, values[i].Value.AsInteger);
+						break;
+					case BlackboardValue.FPVECTOR2VALUE:
+						blackboard->Set(frame, key, values[i].Value.AsFPVector2);
+						break;
+					case BlackboardValue.FPVECTOR3VALUE:
+						blackboard->Set(frame, key, values[i].Value.AsFPVector3);
+						break;
+				}
+			}
+		}
+	}
+}

data/AIBlackboardValueKey.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Quantum
+{
+	// Wrapping the blackboard value key inside a struct gives us a nice way to overload the Unity inspector.
+	[Serializable]
+	public struct AIBlackboardValueKey
+	{
+		public String Key;
+	}
+}

data/AIBlackboardValueType.cs

@@ -0,0 +1,14 @@
+
+namespace Quantum
+{
+	public enum AIBlackboardValueType
+	{
+		Boolean,
+		Byte,
+		Integer,
+		FP,
+		Vector2,
+		Vector3,
+		EntityRef
+	}
+}

data/AIConfig.cs

@@ -0,0 +1,124 @@
+using Photon.Deterministic;
+using System;
+using System.Collections.Generic;
+
+namespace Quantum
+{
+	public partial class AIConfig : AssetObject
+	{
+		public enum EValueType
+		{
+			None,
+			Int,
+			Bool,
+			Byte,
+			FP,
+			FPVector2,
+			FPVector3,
+			String,
+			EntityRef,
+		}
+
+		[Serializable]
+		public class KeyValuePair
+		{
+			public string Key;
+			public EValueType Type;
+			public Value Value;
+		}
+
+		[Serializable]
+		public struct Value
+		{
+			public Int32 Integer;
+			public Boolean Boolean;
+			public Byte Byte;
+			public FP FP;
+			public FPVector2 FPVector2;
+			public FPVector3 FPVector3;
+			public string String;
+			public EntityRef EntityRef;
+		}
+
+		public int Count { get { return KeyValuePairs.Count; } }
+
+		public AssetRefAIConfig DefaultConfig;
+		public List<KeyValuePair> KeyValuePairs = new List<KeyValuePair>(32);
+
+		public KeyValuePair Get(string key)
+		{
+			for (int i = 0; i < KeyValuePairs.Count; i++)
+			{
+				if (KeyValuePairs[i].Key == key)
+					return KeyValuePairs[i];
+			}
+
+			return null;
+		}
+
+		public void Set<T>(string key, T value)
+		{
+			if (string.IsNullOrEmpty(key) == true)
+				return;
+
+			KeyValuePair pair = Get(key);
+
+			if (pair == null)
+			{
+				pair = new KeyValuePair();
+				pair.Key = key;
+				KeyValuePairs.Add(pair);
+			}
+
+			Set(pair, value);
+		}
+
+		private void Set<T>(KeyValuePair pair, T value)
+		{
+			if (value is int intValue)
+			{
+				pair.Type = EValueType.Int;
+				pair.Value.Integer = intValue;
+			}
+			else if (value is bool boolValue)
+			{
+				pair.Type = EValueType.Bool;
+				pair.Value.Boolean = boolValue;
+			}
+			else if (value is Byte byteValue)
+			{
+				pair.Type = EValueType.Byte;
+				pair.Value.Byte = byteValue;
+			}
+			else if (value is FP fpValue)
+			{
+				pair.Type = EValueType.FP;
+				pair.Value.FP = fpValue;
+			}
+			else if (value is FPVector2 fpVector2Value)
+			{
+				pair.Type = EValueType.FPVector2;
+				pair.Value.FPVector2 = fpVector2Value;
+			}
+			else if (value is FPVector3 fpVector3Value)
+			{
+				pair.Type = EValueType.FPVector3;
+				pair.Value.FPVector3 = fpVector3Value;
+			}
+			else if (value is string stringValue)
+			{
+				pair.Type = EValueType.String;
+				pair.Value.String = stringValue;
+			}
+			else if (value is EntityRef entityRefValue)
+			{
+				pair.Type = EValueType.EntityRef;
+				pair.Value.EntityRef = entityRefValue;
+			}
+			else
+			{
+				throw new NotSupportedException(string.Format("AIConfig - Type not supported. Type: {0} Key: {1}", typeof(T), pair.Key));
+			}
+		}
+	}
+}

data/AIConfig.qtn

@@ -0,0 +1 @@
+asset AIConfig;

data/AIFunction.qtn

@@ -0,0 +1,7 @@
+asset AIFunctionByte;
+asset AIFunctionBool;
+asset AIFunctionInt;
+asset AIFunctionFP;
+asset AIFunctionFPVector2;
+asset AIFunctionFPVector3;
+asset AIFunctionEntityRef;

data/AIFunctionAND.cs

@@ -0,0 +1,14 @@
+namespace Quantum
+{
+	[System.Serializable]
+	public unsafe partial class AIFunctionAND : AIFunctionBool
+	{
+		public AIParamBool ValueA;
+		public AIParamBool ValueB;
+
+		public override bool Execute(Frame frame, EntityRef entity)
+		{
+			return ValueA.ResolveFunction(frame, entity) && ValueB.ResolveFunction(frame, entity);
+		}
+	}
+}

data/AIFunctionBool.cs

@@ -0,0 +1,17 @@
+namespace Quantum
+{
+	public unsafe abstract partial class AIFunctionBool
+	{
+		public abstract bool Execute(Frame frame, EntityRef entity);
+	}
+
+	[BotSDKHidden]
+	[System.Serializable]
+	public unsafe partial class DefaultAIFunctionBool : AIFunctionBool
+	{
+		public override bool Execute(Frame frame, EntityRef entity)
+		{
+			return false;
+		}
+	}
+}

data/AIFunctionByte.cs

@@ -0,0 +1,17 @@
+namespace Quantum
+{
+	public unsafe abstract partial class AIFunctionByte
+	{
+		public abstract byte Execute(Frame frame, EntityRef entity);
+	}
+
+	[BotSDKHidden]
+	[System.Serializable]
+	public unsafe partial class DefaultAIFunctionByte : AIFunctionByte
+	{
+		public override byte Execute(Frame frame, EntityRef entity)
+		{
+			return 0;
+		}
+	}
+}

data/AIFunctionEntityRef.cs

@@ -0,0 +1,17 @@
+namespace Quantum
+{
+	public unsafe abstract partial class AIFunctionEntityRef
+	{
+		public abstract EntityRef Execute(Frame frame, EntityRef entity);
+	}
+
+	[BotSDKHidden]
+	[System.Serializable]
+	public unsafe partial class DefaultAIFunctionEntityRef : AIFunctionEntityRef
+	{
+		public override EntityRef Execute(Frame frame, EntityRef entity)
+		{
+			return default(EntityRef);
+		}
+	}
+}

data/AIFunctionFP.cs

@@ -0,0 +1,19 @@
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	public abstract unsafe partial class AIFunctionFP
+	{
+		public abstract FP Execute(Frame frame, EntityRef entity);
+	}
+
+	[BotSDKHidden]
+	[System.Serializable]
+	public unsafe partial class DefaultAIFunctionFP : AIFunctionFP
+	{
+		public override FP Execute(Frame frame, EntityRef entity)
+		{
+			return FP._0;
+		}
+	}
+}

data/AIFunctionFPVector2.cs

@@ -0,0 +1,19 @@
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	public unsafe abstract partial class AIFunctionFPVector2
+	{
+		public abstract FPVector2 Execute(Frame frame, EntityRef entity);
+	}
+
+	[BotSDKHidden]
+	[System.Serializable]
+	public unsafe partial class DefaultAIFunctionFPVector2 : AIFunctionFPVector2
+	{
+		public override FPVector2 Execute(Frame frame, EntityRef entity)
+		{
+			return FPVector2.Zero;
+		}
+	}
+}

data/AIFunctionFPVector3.cs

@@ -0,0 +1,19 @@
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	public unsafe abstract partial class AIFunctionFPVector3
+	{
+		public abstract FPVector3 Execute(Frame frame, EntityRef entity);
+	}
+
+	[BotSDKHidden]
+	[System.Serializable]
+	public unsafe partial class DefaultAIFunctionFPVector3 : AIFunctionFPVector3
+	{
+		public override FPVector3 Execute(Frame frame, EntityRef entity)
+		{
+			return FPVector3.Zero;
+		}
+	}
+}

data/AIFunctionInt.cs

@@ -0,0 +1,17 @@
+namespace Quantum
+{
+	public unsafe abstract partial class AIFunctionInt
+	{
+		public abstract int Execute(Frame frame, EntityRef entity);
+	}
+
+	[BotSDKHidden]
+	[System.Serializable]
+	public unsafe partial class DefaultAIFunctionInt : AIFunctionInt
+	{
+		public override int Execute(Frame frame, EntityRef entity)
+		{
+			return 0;
+		}
+	}
+}

data/AIFunctionNOT.cs

@@ -0,0 +1,13 @@
+namespace Quantum
+{
+	[System.Serializable]
+	public unsafe partial class AIFunctionNOT : AIFunctionBool
+	{
+		public AIParamBool Value;
+
+		public override bool Execute(Frame frame, EntityRef entity)
+		{
+			return !Value.ResolveFunction(frame, entity);
+		}
+	}
+}

data/AIFunctionOR.cs

@@ -0,0 +1,14 @@
+namespace Quantum
+{
+	[System.Serializable]
+	public unsafe partial class AIFunctionOR : AIFunctionBool
+	{
+		public AIParamBool ValueA;
+		public AIParamBool ValueB;
+
+		public override bool Execute(Frame frame, EntityRef entity)
+		{
+			return ValueA.ResolveFunction(frame, entity) || ValueB.ResolveFunction(frame, entity);
+		}
+	}
+}

data/AIParam.Types.cs

@@ -0,0 +1,236 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	[System.Serializable]
+	public unsafe sealed class AIParamInt : AIParam<int>
+	{
+		public static implicit operator AIParamInt(int value) { return new AIParamInt() { DefaultValue = value }; }
+
+		public AssetRefAIFunctionInt FunctionRef;
+
+		[NonSerialized] private AIFunctionInt _cachedFunction;
+
+		protected override int GetBlackboardValue(BlackboardValue value)
+		{
+			return *value.IntegerValue;
+		}
+
+		protected override int GetConfigValue(AIConfig.KeyValuePair configPair)
+		{
+			return configPair.Value.Integer;
+		}
+
+		protected override int GetFunctionValue(Frame frame, EntityRef entity)
+		{
+			if (_cachedFunction == null)
+			{
+				_cachedFunction = frame.FindAsset<AIFunctionInt>(FunctionRef.Id);
+			}
+
+			return _cachedFunction.Execute(frame, entity);
+		}
+	}
+
+	[System.Serializable]
+	public unsafe sealed class AIParamBool : AIParam<bool>
+	{
+		public static implicit operator AIParamBool(bool value) { return new AIParamBool() { DefaultValue = value }; }
+
+		public AssetRefAIFunctionBool FunctionRef;
+
+		[NonSerialized] private AIFunctionBool _cachedFunction;
+
+		protected override bool GetBlackboardValue(BlackboardValue value)
+		{
+			return *value.BooleanValue;
+		}
+
+		protected override bool GetConfigValue(AIConfig.KeyValuePair configPair)
+		{
+			return configPair.Value.Boolean;
+		}
+
+		protected override bool GetFunctionValue(Frame frame, EntityRef entity)
+		{
+			if (_cachedFunction == null)
+			{
+				_cachedFunction = frame.FindAsset<AIFunctionBool>(FunctionRef.Id);
+			}
+
+			return _cachedFunction.Execute(frame, entity);
+		}
+	}
+
+	[System.Serializable]
+	public unsafe sealed class AIParamByte : AIParam<byte>
+	{
+		public static implicit operator AIParamByte(byte value) { return new AIParamByte() { DefaultValue = value }; }
+
+		public AssetRefAIFunctionByte FunctionRef;
+
+		[NonSerialized] private AIFunctionByte _cachedFunction;
+
+		protected override byte GetBlackboardValue(BlackboardValue value)
+		{
+			return *value.ByteValue;
+		}
+
+		protected override byte GetConfigValue(AIConfig.KeyValuePair configPair)
+		{
+			return configPair.Value.Byte;
+		}
+
+		protected override byte GetFunctionValue(Frame frame, EntityRef entity)
+		{
+			if (_cachedFunction == null)
+			{
+				_cachedFunction = frame.FindAsset<AIFunctionByte>(FunctionRef.Id);
+			}
+
+			return _cachedFunction.Execute(frame, entity);
+		}
+	}
+
+	[System.Serializable]
+	public unsafe sealed class AIParamFP : AIParam<FP>
+	{
+		public static implicit operator AIParamFP(FP value) { return new AIParamFP() { DefaultValue = value }; }
+
+		public AssetRefAIFunctionFP FunctionRef;
+
+		[NonSerialized] private AIFunctionFP _cachedFunction;
+
+		protected override FP GetBlackboardValue(BlackboardValue value)
+		{
+			return *value.FPValue;
+		}
+
+		protected override FP GetConfigValue(AIConfig.KeyValuePair configPair)
+		{
+			return configPair.Value.FP;
+		}
+
+		protected override FP GetFunctionValue(Frame frame, EntityRef entity)
+		{
+			if (_cachedFunction == null)
+			{
+				_cachedFunction = frame.FindAsset<AIFunctionFP>(FunctionRef.Id);
+			}
+
+			return _cachedFunction.Execute(frame, entity);
+		}
+	}
+
+	[System.Serializable]
+	public unsafe sealed class AIParamFPVector2 : AIParam<FPVector2>
+	{
+		public static implicit operator AIParamFPVector2(FPVector2 value) { return new AIParamFPVector2() { DefaultValue = value }; }
+
+		public AssetRefAIFunctionFPVector2 FunctionRef;
+
+		[NonSerialized] private AIFunctionFPVector2 _cachedFunction;
+
+		protected override FPVector2 GetBlackboardValue(BlackboardValue value)
+		{
+			return *value.FPVector2Value;
+		}
+
+		protected override FPVector2 GetConfigValue(AIConfig.KeyValuePair configPair)
+		{
+			return configPair.Value.FPVector2;
+		}
+
+		protected override FPVector2 GetFunctionValue(Frame frame, EntityRef entity)
+		{
+			if (_cachedFunction == null)
+			{
+				_cachedFunction = frame.FindAsset<AIFunctionFPVector2>(FunctionRef.Id);
+			}
+
+			return _cachedFunction.Execute(frame, entity);
+		}
+	}
+
+	[System.Serializable]
+	public unsafe sealed class AIParamFPVector3 : AIParam<FPVector3>
+	{
+		public static implicit operator AIParamFPVector3(FPVector3 value) { return new AIParamFPVector3() { DefaultValue = value }; }
+
+		public AssetRefAIFunctionFPVector3 FunctionRef;
+
+		[NonSerialized] private AIFunctionFPVector3 _cachedFunction;
+
+		protected override FPVector3 GetBlackboardValue(BlackboardValue value)
+		{
+			return *value.FPVector3Value;
+		}
+
+		protected override FPVector3 GetConfigValue(AIConfig.KeyValuePair configPair)
+		{
+			return configPair.Value.FPVector3;
+		}
+
+		protected override FPVector3 GetFunctionValue(Frame frame, EntityRef entity)
+		{
+			if (_cachedFunction == null)
+			{
+				_cachedFunction = frame.FindAsset<AIFunctionFPVector3>(FunctionRef.Id);
+			}
+
+			return _cachedFunction.Execute(frame, entity);
+		}
+	}
+
+	[System.Serializable]
+	public unsafe sealed class AIParamString : AIParam<string>
+	{
+		public static implicit operator AIParamString(string value) { return new AIParamString() { DefaultValue = value }; }
+
+		protected override string GetBlackboardValue(BlackboardValue value)
+		{
+			throw new NotSupportedException("Blackboard variables as strings are not supported.");
+		}
+
+		protected override string GetConfigValue(AIConfig.KeyValuePair configPair)
+		{
+			return configPair.Value.String;
+		}
+
+		protected override string GetFunctionValue(Frame frame, EntityRef entity)
+		{
+			return default;
+		}
+	}
+
+	[System.Serializable]
+	public unsafe sealed class AIParamEntityRef : AIParam<EntityRef>
+	{
+		public static implicit operator AIParamEntityRef(EntityRef value) { return new AIParamEntityRef() { DefaultValue = value }; }
+
+		public AssetRefAIFunctionEntityRef FunctionRef;
+
+		[NonSerialized] private AIFunctionEntityRef _cachedFunction;
+
+		protected override EntityRef GetBlackboardValue(BlackboardValue value)
+		{
+			return *value.EntityRefValue;
+		}
+
+		protected override EntityRef GetConfigValue(AIConfig.KeyValuePair configPair)
+		{
+			return configPair.Value.EntityRef;
+		}
+
+		protected override EntityRef GetFunctionValue(Frame frame, EntityRef entity)
+		{
+			if (_cachedFunction == null)
+			{
+				_cachedFunction = frame.FindAsset<AIFunctionEntityRef>(FunctionRef.Id);
+			}
+
+			return _cachedFunction.Execute(frame, entity);
+		}
+	}
+}

data/AIParam.cs

@@ -0,0 +1,76 @@
+using System;
+
+namespace Quantum
+{
+	public enum AIParamSource
+	{
+		None,
+		Value,
+		Config,
+		Blackboard,
+		Function,
+	}
+
+	[Serializable]
+	public abstract unsafe class AIParam<T>
+	{
+		public AIParamSource Source = AIParamSource.Value;
+		public string Key;
+		public T DefaultValue;
+
+		/// <summary>
+		/// Use this to solve the AIParam value when the source of the value is unkown
+		/// </summary>
+		public T Resolve(Frame frame, EntityRef entity, AIBlackboardComponent* blackboard, AIConfig aiConfig)
+		{
+			if (Source == AIParamSource.Value || (Source != AIParamSource.Function && string.IsNullOrEmpty(Key) == true))
+				return DefaultValue;
+
+			switch (Source)
+			{
+				case AIParamSource.Blackboard:
+					BlackboardValue blackboardValue = blackboard->GetBlackboardValue(frame, Key);
+					return GetBlackboardValue(blackboardValue);
+
+				case AIParamSource.Config:
+					AIConfig.KeyValuePair configPair = aiConfig != null ? aiConfig.Get(Key) : null;
+					return configPair != null ? GetConfigValue(configPair) : DefaultValue;
+
+				case AIParamSource.Function:
+					return GetFunctionValue(frame, entity);
+			}
+
+			return default(T);
+		}
+
+		/// <summary>
+		/// Use this if the it is known that the AIParam stores specifically a Blackboard value
+		/// </summary>
+		public unsafe T ResolveBlackboard(Frame frame, AIBlackboardComponent* blackboard)
+		{
+			BlackboardValue blackboardValue = blackboard->GetBlackboardValue(frame, Key);
+			return GetBlackboardValue(blackboardValue);
+		}
+
+		/// <summary>
+		/// Use this if the it is known that the AIParam stores specifically a Config value
+		/// </summary>
+		public unsafe T ResolveConfig(Frame frame, AIConfig aiConfig)
+		{
+			AIConfig.KeyValuePair configPair = aiConfig != null ? aiConfig.Get(Key) : null;
+			return configPair != null ? GetConfigValue(configPair) : DefaultValue;
+		}
+
+		/// <summary>
+		/// Use this if the it is known that the AIParam stores specifically a Func
+		/// </summary>
+		public unsafe T ResolveFunction(Frame frame, EntityRef entity)
+		{
+			return GetFunctionValue(frame, entity);
+		}
+
+		protected abstract T GetBlackboardValue(BlackboardValue value);
+		protected abstract T GetConfigValue(AIConfig.KeyValuePair configPair);
+		protected abstract T GetFunctionValue(Frame frame, EntityRef entity);
+	}
+}

data/AIParamExtensions.cs

@@ -0,0 +1,45 @@
+namespace Quantum
+{
+	public static unsafe partial class AIParamExtensions
+	{
+		public static T ResolveFromHFSM<T>(this AIParam<T> aiParam, Frame frame, EntityRef entity)
+		{
+			var aiConfigRef = aiParam.Source == AIParamSource.Config
+				? frame.Unsafe.GetPointer<HFSMAgent>(entity)->Config
+				: default;
+
+			return aiParam.Resolve(frame, entity, aiConfigRef);
+		}
+
+		public static T ResolveFromGOAP<T>(this AIParam<T> aiParam, Frame frame, EntityRef entity)
+		{
+			var aiConfigRef = aiParam.Source == AIParamSource.Config
+				? frame.Unsafe.GetPointer<GOAPAgent>(entity)->Config
+				: default;
+
+			return aiParam.Resolve(frame, entity, aiConfigRef);
+		}
+
+		public static T ResolveFromBT<T>(this AIParam<T> aiParam, Frame frame, EntityRef entity)
+		{
+			var aiConfigRef = aiParam.Source == AIParamSource.Config
+				? frame.Unsafe.GetPointer<BTAgent>(entity)->Config
+				: default;
+
+			return aiParam.Resolve(frame, entity, aiConfigRef);
+		}
+
+		public static T Resolve<T>(this AIParam<T> aiParam, Frame frame, EntityRef entity, AssetRefAIConfig aiConfigRef)
+		{
+			var blackboard = aiParam.Source == AIParamSource.Blackboard
+				? frame.Unsafe.GetPointer<AIBlackboardComponent>(entity)
+				: null;
+
+			var aiConfig = aiParam.Source == AIParamSource.Config
+				? frame.FindAsset<AIConfig>(aiConfigRef.Id)
+				: null;
+
+			return aiParam.Resolve(frame, entity, blackboard, aiConfig);
+		}
+	}
+}

data/AssemblyInfo.cs

@@ -0,0 +1,17 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("quantum.code")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("quantum.code")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: ComVisible(false)]
+[assembly: Guid("fbf32099-b197-4ab9-8e5a-b44d9d3750bd")]
+[assembly: AssemblyVersion("2.0.0.0")]
+[assembly: AssemblyFileVersion("2.0.0.0")]
+[assembly: AssemblyInformationalVersion("2.0.0 RC2N 501 2.0/develop (99c627e06)")]
+

data/BTAbort.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace Quantum
+{
+	public enum BTAbort
+	{
+		None,
+		Self,
+		LowerPriority,
+		Both
+	}
+
+	public static class BTAbortExtensions
+	{
+		public static Boolean IsSelf(this BTAbort abort)
+		{
+			return abort == BTAbort.Self || abort == BTAbort.Both;
+		}
+
+		public static Boolean IsLowerPriority(this BTAbort abort)
+		{
+			return abort == BTAbort.LowerPriority || abort == BTAbort.Both;
+		}
+	}
+}

data/BTAgent.User.Data.cs

@@ -0,0 +1,96 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	public unsafe partial struct BTAgent
+	{
+		#region Int and FP Data
+		// Getter / Setters of node FP and Int32 data
+		public void AddFPData(Frame frame, FP fpValue)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			BTDataValue newDataValue = new BTDataValue();
+			*newDataValue.FPValue = fpValue;
+			nodesDataList.Add(newDataValue);
+		}
+
+		public void AddIntData(Frame frame, Int32 intValue)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			BTDataValue newDataValue = new BTDataValue();
+			*newDataValue.IntValue = intValue;
+			nodesDataList.Add(newDataValue);
+		}
+
+		public void SetFPData(Frame frame, FP value, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			*nodesDataList.GetPointer(index)->FPValue = value;
+		}
+
+		public void SetIntData(Frame frame, Int32 value, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			*nodesDataList.GetPointer(index)->IntValue = value;
+		}
+
+		public FP GetFPData(Frame frame, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			return *nodesDataList.GetPointer(index)->FPValue;
+		}
+
+		public Int32 GetIntData(Frame frame, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			return *nodesDataList.GetPointer(index)->IntValue;
+		}
+		#endregion
+
+		// -- THREADSAFE
+
+		#region THREADSAFE Int and FP Data
+		// Getter / Setters of node FP and Int32 data
+		public void AddFPData(FrameThreadSafe frame, FP fpValue)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			BTDataValue newDataValue = new BTDataValue();
+			*newDataValue.FPValue = fpValue;
+			nodesDataList.Add(newDataValue);
+		}
+
+		public void AddIntData(FrameThreadSafe frame, Int32 intValue)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			BTDataValue newDataValue = new BTDataValue();
+			*newDataValue.IntValue = intValue;
+			nodesDataList.Add(newDataValue);
+		}
+
+		public void SetFPData(FrameThreadSafe frame, FP value, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			*nodesDataList.GetPointer(index)->FPValue = value;
+		}
+
+		public void SetIntData(FrameThreadSafe frame, Int32 value, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			*nodesDataList.GetPointer(index)->IntValue = value;
+		}
+
+		public FP GetFPData(FrameThreadSafe frame, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			return *nodesDataList.GetPointer(index)->FPValue;
+		}
+
+		public Int32 GetIntData(FrameThreadSafe frame, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			return *nodesDataList.GetPointer(index)->IntValue;
+		}
+		#endregion
+	}
+}

data/BTAgent.User.cs

@@ -0,0 +1,235 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	public unsafe partial struct BTAgent
+	{
+		// Used to setup info on the Unity debugger
+		public string GetTreeAssetName(Frame frame) => frame.FindAsset<BTRoot>(Tree.Id).Path;
+
+		public bool IsAborting => AbortNodeId != 0;
+
+		public AIConfig GetConfig(Frame frame)
+		{
+			return frame.FindAsset<AIConfig>(Config.Id);
+		}
+
+		public void Initialize(Frame frame, EntityRef entityRef, BTAgent* agent, AssetRefBTNode tree, bool force = false)
+		{
+			if (this.Tree != default && force == false)
+				return;
+
+			// -- Cache the tree
+			BTRoot treeAsset = frame.FindAsset<BTRoot>(tree.Id);
+			this.Tree = treeAsset;
+
+			// -- Allocate data
+			// Success/Fail/Running
+			NodesStatus = frame.AllocateList<Byte>(treeAsset.NodesAmount);
+
+			// Next tick in which each service shall be updated
+			ServicesEndTimes = frame.AllocateList<FP>(4);
+
+			// Node data, such as FP for timers, Integers for IDs
+			BTDataValues = frame.AllocateList<BTDataValue>(4);
+
+			// The Services contained in the current sub-tree,
+			// which should be updated considering its intervals
+			ActiveServices = frame.AllocateList<AssetRefBTService>(4);
+
+			// The Dynamic Composites contained in the current sub-tree,
+			// which should be re-checked every tick
+			DynamicComposites = frame.AllocateList<AssetRefBTComposite>(4);
+
+			// -- Cache the Blackboard (if any)
+			AIBlackboardComponent* blackboard = null;
+			if (frame.Has<AIBlackboardComponent>(entityRef))
+			{
+				blackboard = frame.Unsafe.GetPointer<AIBlackboardComponent>(entityRef);
+			}
+
+			// -- Initialize the tree
+			treeAsset.InitializeTree(frame, agent, blackboard);
+
+			// -- Trigger the debugging event (mostly for the Unity side)
+			BTManager.OnSetupDebugger?.Invoke(entityRef, treeAsset.Path);
+		}
+
+		public void Free(Frame frame)
+		{
+			Tree = default;
+			frame.FreeList<Byte>(NodesStatus);
+			frame.FreeList<FP>(ServicesEndTimes);
+			frame.FreeList<BTDataValue>(BTDataValues);
+			frame.FreeList<AssetRefBTService>(ActiveServices);
+			frame.FreeList<AssetRefBTComposite>(DynamicComposites);
+		}
+
+		#region Int and FP Data
+		// Getter / Setters of node FP and Int32 data
+		public void AddFPData(Frame frame, FP fpValue)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			BTDataValue newDataValue = new BTDataValue();
+			*newDataValue.FPValue = fpValue;
+			nodesDataList.Add(newDataValue);
+		}
+
+		public void AddIntData(Frame frame, Int32 intValue)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			BTDataValue newDataValue = new BTDataValue();
+			*newDataValue.IntValue = intValue;
+			nodesDataList.Add(newDataValue);
+		}
+
+		public void SetFPData(Frame frame, FP value, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			*nodesDataList.GetPointer(index)->FPValue = value;
+		}
+
+		public void SetIntData(Frame frame, Int32 value, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			*nodesDataList.GetPointer(index)->IntValue = value;
+		}
+
+		public FP GetFPData(Frame frame, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			return *nodesDataList.GetPointer(index)->FPValue;
+		}
+
+		public Int32 GetIntData(Frame frame, Int32 index)
+		{
+			var nodesDataList = frame.ResolveList<BTDataValue>(BTDataValues);
+			return *nodesDataList.GetPointer(index)->IntValue;
+		}
+		#endregion
+
+		public void Update(ref BTParams btParams)
+		{
+			if (btParams.Agent->Current == null)
+			{
+				btParams.Agent->Current = btParams.Agent->Tree;
+			}
+
+			RunDynamicComposites(btParams);
+
+			BTNode node = btParams.Frame.FindAsset<BTNode>(btParams.Agent->Current.Id);
+			UpdateSubtree(btParams, node);
+
+			BTManager.ClearBTParams(btParams);
+		}
+
+		// We run the dynamic composites contained on the current sub-tree (if any)
+		// If any of them result in "False", we abort the current sub-tree
+		// and take the execution back to the topmost decorator so the agent can choose another path
+		private void RunDynamicComposites(BTParams btParams)
+		{
+			var frame = btParams.Frame;
+			var dynamicComposites = frame.ResolveList<AssetRefBTComposite>(DynamicComposites);
+
+			for (int i = 0; i < dynamicComposites.Count; i++)
+			{
+				var compositeRef = dynamicComposites.GetPointer(i);
+				var composite = frame.FindAsset<BTComposite>(compositeRef->Id);
+				var dynamicResult = composite.OnDynamicRun(btParams);
+
+				if (dynamicResult == false)
+				{
+					btParams.Agent->Current = composite.TopmostDecorator;
+					dynamicComposites.Remove(*compositeRef);
+					composite.OnReset(btParams);
+					return;
+				}
+			}
+		}
+
+		private void UpdateSubtree(BTParams btParams, BTNode node, bool continuingAbort = false)
+		{
+			// Start updating the tree from the Current agent's node
+			var result = node.RunUpdate(btParams, continuingAbort);
+
+			// If the current node completes, go up in the tree until we hit a composite
+			// Run that one. On success or fail continue going up.
+			while (result != BTStatus.Running && node.Parent != null)
+			{
+				// As we are traversing the tree up, we allow nodes to remove any
+				// data that is only needed locally
+				node.OnExit(btParams);
+
+				node = node.Parent;
+				if (node.NodeType == BTNodeType.Composite)
+				{
+					((BTComposite)node).ChildCompletedRunning(btParams, result);
+					result = node.RunUpdate(btParams, continuingAbort);
+				}
+
+				if (node.NodeType == BTNodeType.Decorator)
+				{
+					((BTDecorator)node).EvaluateAbortNode(btParams);
+				}
+			}
+
+			BTService.TickServices(btParams);
+
+			if (result != BTStatus.Running)
+			{
+				BTNode tree = btParams.Frame.FindAsset<BTNode>(btParams.Agent->Tree.Id);
+				tree.OnReset(btParams);
+				btParams.Agent->Current = btParams.Agent->Tree;
+				BTManager.OnTreeCompleted?.Invoke(btParams.Entity);
+				//Log.Info("Behaviour Tree completed with result '{0}'. It will re-start from '{1}'", result, btParams.Agent->Current.Id);
+			}
+		}
+
+		public unsafe void AbortLowerPriority(BTParams btParams, BTNode node)
+		{
+			// Go up and find the next interesting node (composite or root)
+			var topNode = node;
+			while (
+				topNode.NodeType != BTNodeType.Composite &&
+				topNode.NodeType != BTNodeType.Root)
+			{
+				topNode = topNode.Parent;
+			}
+
+			if (topNode.NodeType == BTNodeType.Root)
+			{
+				return;
+			}
+
+			var nodeAsComposite = (topNode as BTComposite);
+			nodeAsComposite.AbortNodes(btParams, nodeAsComposite.GetCurrentChild(btParams.Frame, btParams.Agent) + 1);
+		}
+
+		// Used to react to blackboard changes which are observed by Decorators
+		// This is triggered by the Blackboard Entry itself, which has a list of Decorators that observes it
+		public unsafe void OnDecoratorReaction(BTParams btParams, BTNode node, BTAbort abort, out bool abortSelf, out bool abortLowerPriotity)
+		{
+			abortSelf = false;
+			abortLowerPriotity = false;
+
+			var status = node.GetStatus(btParams.Frame, btParams.Agent);
+
+			if (abort.IsSelf() && (status == BTStatus.Running || status == BTStatus.Inactive))
+			{
+				// Check condition again
+				if (node.DryRun(btParams) == false)
+				{
+					abortSelf = true;
+					node.OnAbort(btParams);
+				}
+			}
+
+			if (abort.IsLowerPriority())
+			{
+				AbortLowerPriority(btParams, node);
+				abortLowerPriotity = true;
+			}
+		}
+	}
+}

data/BTBlackboardCompare.cs

@@ -0,0 +1,51 @@
+using System;
+
+namespace Quantum
+{
+	/// <summary>
+	/// Reactive Decorator sample. Listens to changes on two Blackboard entries.
+	/// </summary>
+	[Serializable]
+	public unsafe class BTBlackboardCompare : BTDecorator
+	{
+		// We let the user define, on the Visual Editor, which Blackboard entries
+		// shall be observed by this Decorator
+		public AIBlackboardValueKey BlackboardKeyA;
+		public AIBlackboardValueKey BlackboardKeyB;
+
+		public override void OnEnter(BTParams btParams)
+		{
+			base.OnEnter(btParams);
+
+			// Whenever we enter this Decorator...
+			// We register it as a Reactive Decorator so, whenever the entries are changed,
+			// the DryRun is executed again, possibly aborting the current execution
+			btParams.Blackboard->RegisterReactiveDecorator(btParams.Frame, BlackboardKeyA.Key, this);
+			btParams.Blackboard->RegisterReactiveDecorator(btParams.Frame, BlackboardKeyB.Key, this);
+		}
+
+		public override void OnExit(BTParams btParams)
+		{
+			base.OnExit(btParams);
+			// Whenever the execution goes higher, it means that this Decorator isn't in the current subtree anymore
+			// So we unregister this Decorator from the Reactive list. This means that if the Blackboard entries
+			// get changed, this Decorator will not react anymore
+			btParams.Blackboard->UnregisterReactiveDecorator(btParams.Frame, BlackboardKeyA.Key, this);
+			btParams.Blackboard->UnregisterReactiveDecorator(btParams.Frame, BlackboardKeyB.Key, this);
+		}
+
+		// We just check if A is greater than B. If that's the case
+		// PS: this gets called in THREE possible situations:
+		// 1 - When the execution is goign DOWN on the tree and this Decorator is found
+		// 2 - If changes to the observed blackboard entries happen
+		// 3 - If this is inside a Dynamic Composite node
+		public override Boolean DryRun(BTParams btParams)
+		{
+			var blackboard = btParams.Blackboard;
+			var A = blackboard->GetInteger(btParams.Frame, BlackboardKeyA.Key);
+			var B = blackboard->GetInteger(btParams.Frame, BlackboardKeyB.Key);
+
+			return A > B;
+		}
+	}
+}

data/BTComposite.cs

@@ -0,0 +1,178 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	public unsafe abstract partial class BTComposite : BTNode
+	{
+		public AssetRefBTNode[] Children;
+		public AssetRefBTService[] Services;
+		[BotSDKHidden] public AssetRefBTNode TopmostDecorator;
+
+		public BTDataIndex CurrentChildIndex;
+
+		protected BTNode[] _childInstances;
+		protected BTService[] _serviceInstances;
+		protected BTNode _topmostDecoratorInstance;
+
+		public bool IsDynamic;
+
+		public BTNode[] ChildInstances
+		{
+			get
+			{
+				return _childInstances;
+			}
+		}
+
+		public BTService[] ServiceInstances
+		{
+			get
+			{
+				return _serviceInstances;
+			}
+		}
+
+		public override BTNodeType NodeType
+		{
+			get
+			{
+				return BTNodeType.Composite;
+			}
+		}
+
+		internal Int32 GetCurrentChild(Frame frame, BTAgent* agent)
+		{
+			Byte currentChild = (Byte)agent->GetIntData(frame, CurrentChildIndex.Index);
+			return currentChild;
+		}
+
+		internal void SetCurrentChild(Frame frame, Int32 currentIndex, BTAgent* agent)
+		{
+			agent->SetIntData(frame, currentIndex, CurrentChildIndex.Index);
+		}
+
+		/// <summary>
+		/// When a Composite node is Updated, it only increase the current child updated
+		/// when the child results in either FAIL/SUCCESS. So we need this callback
+		/// to be used when the child was RUNNING and then had some result, to properly increase the current 
+		/// child ID
+		/// </summary>
+		/// <param name="btParams"></param>
+		/// <param name="childResult"></param>
+		internal virtual void ChildCompletedRunning(BTParams btParams, BTStatus childResult)
+		{
+		}
+
+		public override void Init(Frame frame, AIBlackboardComponent* blackboard, BTAgent* agent)
+		{
+			base.Init(frame, blackboard, agent);
+
+			agent->AddIntData(frame, 0);
+
+			for (Int32 i = 0; i < Services.Length; i++)
+			{
+				BTService service = frame.FindAsset<BTService>(Services[i].Id);
+				service.Init(frame, agent, blackboard);
+			}
+		}
+
+		public override void OnEnter(BTParams btParams)
+		{
+			BTManager.OnNodeEnter?.Invoke(btParams.Entity, Guid.Value);
+			SetCurrentChild(btParams.Frame, 0, btParams.Agent);
+		}
+
+		public override void OnEnterRunning(BTParams btParams)
+		{
+			var activeServicesList = btParams.Frame.ResolveList<AssetRefBTService>(btParams.Agent->ActiveServices);
+
+			for (Int32 i = 0; i < _serviceInstances.Length; i++)
+			{
+				_serviceInstances[i].OnEnter(btParams);
+
+				activeServicesList.Add(Services[i]);
+			}
+
+			if (IsDynamic == true)
+			{
+				var dynamicComposites = btParams.Frame.ResolveList<AssetRefBTComposite>(btParams.Agent->DynamicComposites);
+				dynamicComposites.Add(this);
+			}
+		}
+
+		public override void OnReset(BTParams btParams)
+		{
+			base.OnReset(btParams);
+
+			OnExit(btParams);
+
+			for (Int32 i = 0; i < _childInstances.Length; i++)
+				_childInstances[i].OnReset(btParams);
+		}
+
+		public override void OnExit(BTParams btParams)
+		{
+			base.OnExit(btParams);
+
+			BTManager.OnNodeExit?.Invoke(btParams.Entity, Guid.Value);
+
+			var activeServicesList = btParams.Frame.ResolveList<AssetRefBTService>(btParams.Agent->ActiveServices);
+			for (Int32 i = 0; i < _serviceInstances.Length; i++)
+			{
+				activeServicesList.Remove(Services[i]);
+			}
+
+			if (IsDynamic == true)
+			{
+				var dynamicComposites = btParams.Frame.ResolveList<AssetRefBTComposite>(btParams.Agent->DynamicComposites);
+				dynamicComposites.Remove(this);
+			}
+		}
+
+		public override bool OnDynamicRun(BTParams btParams)
+		{
+			if (_topmostDecoratorInstance != null)
+			{
+				return _topmostDecoratorInstance.OnDynamicRun(btParams);
+			}
+
+			return true;
+		}
+
+
+		public void AbortNodes(BTParams btParams, Int32 firstIndex = 0)
+		{
+			for (int i = firstIndex; i < _childInstances.Length; i++)
+			{
+				_childInstances[i].SetStatus(btParams.Frame, BTStatus.Abort, btParams.Agent);
+			}
+		}
+
+		public override void Loaded(IResourceManager resourceManager, Native.Allocator allocator)
+		{
+			base.Loaded(resourceManager, allocator);
+
+			// Cache the child assets links
+			_childInstances = new BTNode[Children.Length];
+			for (Int32 i = 0; i < Children.Length; i++)
+			{
+				_childInstances[i] = (BTNode)resourceManager.GetAsset(Children[i].Id);
+				_childInstances[i].Parent = this;
+				_childInstances[i].ParentIndex = i;
+			}
+
+			// Cache the service assets links
+			_serviceInstances = new BTService[Services.Length];
+			for (Int32 i = 0; i < Services.Length; i++)
+			{
+				_serviceInstances[i] = (BTService)resourceManager.GetAsset(Services[i].Id);
+			}
+
+			if (TopmostDecorator != null)
+			{
+				_topmostDecoratorInstance = (BTDecorator)resourceManager.GetAsset(TopmostDecorator.Id);
+			}
+		}
+	}
+}

data/BTCooldown.cs

@@ -0,0 +1,54 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	[Serializable]
+	public unsafe partial class BTCooldown : BTDecorator
+	{
+		// How many time should we wait
+		public FP CooldownTime;
+
+		// An indexer so we know when the time started counting
+		public BTDataIndex StartTimeIndex;
+
+		public override void Init(Frame frame, AIBlackboardComponent* blackboard, BTAgent* agent)
+		{
+			base.Init(frame, blackboard, agent);
+
+			// We allocate space on the BTAgent so we can store the Start Time
+			agent->AddFPData(frame, 0);
+		}
+
+		protected override BTStatus OnUpdate(BTParams btParams)
+		{
+			var result = base.OnUpdate(btParams);
+
+			// We let the time check, which happens on the DryRun, happen
+			// If it results in success, then we store on the BTAgent the time value of the moment that it happened
+			if (result == BTStatus.Success)
+			{
+				var currentTime = btParams.Frame.DeltaTime * btParams.Frame.Number;
+
+				var frame = btParams.Frame;
+				var entity = btParams.Entity;
+				btParams.Agent->SetFPData(frame, currentTime, StartTimeIndex.Index);
+			}
+
+			return result;
+		}
+
+		// We get the Start Time stored on the BTAgent, then we check if the time + cooldown is already over
+		// If it is not over, then we return False, blocking the execution of the children nodes
+		public override Boolean DryRun(BTParams btParams)
+		{
+			var frame = btParams.Frame;
+			var entity = btParams.Entity;
+			FP startTime = btParams.Agent->GetFPData(frame, StartTimeIndex.Index);
+
+			var currentTime = btParams.Frame.DeltaTime * btParams.Frame.Number;
+
+			return currentTime >= startTime + CooldownTime;
+		}
+	}
+}

data/BTDataIndex.User.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Quantum
+{
+	[BotSDKHidden]
+	[Serializable]
+	// Used so we can track it easier on the Visual Editor
+	partial struct BTDataIndex
+	{
+	}
+}

data/BTDecorator.cs

@@ -0,0 +1,97 @@
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	public abstract unsafe partial class BTDecorator : BTNode
+	{
+		[BotSDKHidden] public AssetRefBTNode Child;
+		protected BTNode _childInstance;
+		public BTAbort AbortType;
+
+		public BTNode ChildInstance
+		{
+			get
+			{
+				return _childInstance;
+			}
+		}
+
+		public override BTNodeType NodeType
+		{
+			get
+			{
+				return BTNodeType.Decorator;
+			}
+		}
+
+		public override void OnReset(BTParams btParams)
+		{
+			base.OnReset(btParams);
+
+			OnExit(btParams);
+
+			if (_childInstance != null)
+				_childInstance.OnReset(btParams);
+
+			BTManager.OnDecoratorReset?.Invoke(btParams.Entity, Guid.Value);
+		}
+
+		public override void OnExit(BTParams btParams)
+		{
+			base.OnExit(btParams);
+		}
+
+		protected override BTStatus OnUpdate(BTParams btParams)
+		{
+			if (DryRun(btParams) == true)
+			{
+				BTManager.OnDecoratorChecked?.Invoke(btParams.Entity, Guid.Value, true);
+
+				if (_childInstance != null)
+				{
+					var childResult = _childInstance.RunUpdate(btParams);
+					if (childResult == BTStatus.Abort)
+					{
+						EvaluateAbortNode(btParams);
+						SetStatus(btParams.Frame, BTStatus.Abort, btParams.Agent);
+						return BTStatus.Abort;
+					}
+
+					return childResult;
+				}
+
+				return BTStatus.Success;
+			}
+
+			BTManager.OnDecoratorChecked?.Invoke(btParams.Entity, Guid.Value, false);
+
+			return BTStatus.Failure;
+		}
+
+		public override bool OnDynamicRun(BTParams btParams)
+		{
+			var result = DryRun(btParams);
+			if (result == false)
+			{
+				return false;
+			}
+			else if (ChildInstance.NodeType != BTNodeType.Decorator)
+			{
+				return true;
+			}
+			else
+			{
+				return ChildInstance.OnDynamicRun(btParams);
+			}
+		}
+
+		public override void Loaded(IResourceManager resourceManager, Native.Allocator allocator)
+		{
+			base.Loaded(resourceManager, allocator);
+
+			// Cache the child
+			_childInstance = (BTNode)resourceManager.GetAsset(Child.Id);
+			_childInstance.Parent = this;
+		}
+	}
+}

data/BTForceResult.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace Quantum
+{
+	[Serializable]
+	public unsafe partial class BTForceResult : BTDecorator
+	{
+		public BTStatus Result;
+
+		protected override BTStatus OnUpdate(BTParams btParams)
+		{
+			if (_childInstance != null)
+				_childInstance.RunUpdate(btParams);
+
+			return Result;
+		}
+
+		public override Boolean DryRun(BTParams btParams)
+		{
+			return true;
+		}
+	}
+}

data/BTLeaf.cs

@@ -0,0 +1,82 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	public unsafe abstract partial class BTLeaf : BTNode
+	{
+		public AssetRefBTService[] Services;
+		protected BTService[] _serviceInstances;
+		public BTService[] ServiceInstances
+		{
+			get
+			{
+				return _serviceInstances;
+			}
+		}
+
+		public override BTNodeType NodeType
+		{
+			get
+			{
+				return BTNodeType.Leaf;
+			}
+		}
+
+		public override unsafe void Init(Frame frame, AIBlackboardComponent* blackboard, BTAgent* agent)
+		{
+			base.Init(frame, blackboard, agent);
+
+			for (int i = 0; i < Services.Length; i++)
+			{
+				BTService service = frame.FindAsset<BTService>(Services[i].Id);
+				service.Init(frame, agent, blackboard);
+			}
+		}
+
+		public override void OnEnterRunning(BTParams btParams)
+		{
+			var activeServicesList = btParams.Frame.ResolveList<AssetRefBTService>(btParams.Agent->ActiveServices);
+			for (int i = 0; i < _serviceInstances.Length; i++)
+			{
+				_serviceInstances[i].OnEnter(btParams);
+				activeServicesList.Add(Services[i]);
+			}
+		}
+
+		public override void OnEnter(BTParams btParams)
+		{
+			base.OnEnter(btParams);
+			BTManager.OnNodeEnter?.Invoke(btParams.Entity, Guid.Value);
+		}
+
+		public override void OnExit(BTParams btParams)
+		{
+			var activeServicesList = btParams.Frame.ResolveList<AssetRefBTService>(btParams.Agent->ActiveServices);
+			for (Int32 i = 0; i < _serviceInstances.Length; i++)
+			{
+				activeServicesList.Remove(Services[i]);
+			}
+
+			BTManager.OnNodeExit?.Invoke(btParams.Entity, Guid.Value);
+		}
+
+		public override void OnReset(BTParams btParams)
+		{
+			base.OnReset(btParams);
+			OnExit(btParams);
+		}
+
+		public override void Loaded(IResourceManager resourceManager, Native.Allocator allocator)
+		{
+			base.Loaded(resourceManager, allocator);
+
+			// Cache the service assets links
+			_serviceInstances = new BTService[Services.Length];
+			for (int i = 0; i < Services.Length; i++)
+			{
+				_serviceInstances[i] = (BTService)resourceManager.GetAsset(Services[i].Id);
+			}
+		}
+	}
+}

data/BTLoop.cs

@@ -0,0 +1,87 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	[Serializable]
+	public unsafe partial class BTLoop : BTDecorator
+	{
+		public Int32 LoopIterations;
+		public Boolean LoopForever;
+		public FP LoopTimeout = -FP._1;
+
+		public BTDataIndex StartTimeIndex;
+		public BTDataIndex IterationCountIndex;
+
+		public override void Init(Frame frame, AIBlackboardComponent* blackboard, BTAgent* agent)
+		{
+			base.Init(frame, blackboard, agent);
+
+			agent->AddFPData(frame, 0);
+			agent->AddIntData(frame, 0);
+		}
+
+		public override void OnEnter(BTParams btParams)
+		{
+			base.OnEnter(btParams);
+
+			var frame = btParams.Frame;
+			var currentTime = frame.DeltaTime * frame.Number;
+
+			btParams.Agent->SetFPData(frame, currentTime, StartTimeIndex.Index);
+			btParams.Agent->SetIntData(frame, 0, IterationCountIndex.Index);
+		}
+
+		protected override BTStatus OnUpdate(BTParams btParams)
+		{
+			var frame = btParams.Frame;
+
+			int iteration = btParams.Agent->GetIntData(frame, IterationCountIndex.Index) + 1;
+			btParams.Agent->SetIntData(frame, iteration, IterationCountIndex.Index);
+
+			if (DryRun(btParams) == false)
+			{
+				return BTStatus.Success;
+			}
+
+			var childResult = BTStatus.Failure;
+			if (_childInstance != null)
+			{
+				_childInstance.SetStatus(btParams.Frame, BTStatus.Inactive, btParams.Agent);
+				childResult = _childInstance.RunUpdate(btParams);
+			}
+
+			return childResult;
+		}
+
+		public override Boolean DryRun(BTParams btParams)
+		{
+			if (LoopForever && LoopTimeout < FP._0)
+			{
+				return true;
+			}
+			else if (LoopForever)
+			{
+				var frame = btParams.Frame;
+				FP startTime = btParams.Agent->GetFPData(frame, StartTimeIndex.Index);
+
+				var currentTime = frame.DeltaTime * frame.Number;
+				if (currentTime < startTime + LoopTimeout)
+				{
+					return true;
+				}
+			}
+			else
+			{
+				var frame = btParams.Frame;
+				int iteration = btParams.Agent->GetIntData(frame, IterationCountIndex.Index);
+				if (iteration <= LoopIterations)
+				{
+					return true;
+				}
+			}
+
+			return false;
+		}
+	}
+}

data/BTNode.cs

@@ -0,0 +1,178 @@
+using System;
+
+namespace Quantum
+{
+
+	public unsafe abstract partial class BTNode
+	{
+
+		[BotSDKHidden] public String Label;
+		[BotSDKHidden] public Int32 Id;
+
+		[NonSerialized] internal BTNode Parent;
+		[NonSerialized] internal Int32 ParentIndex;
+
+		public abstract BTNodeType NodeType { get; }
+
+		/// <summary>
+		/// Called once, for every Node, when the BT is being initialized
+		/// </summary>
+		public virtual void Init(Frame frame, AIBlackboardComponent* blackboard, BTAgent* agent)
+		{
+			var statusList = frame.ResolveList(agent->NodesStatus);
+			statusList.Add(0);
+		}
+
+		// -- STATUS --
+		public BTStatus GetStatus(Frame frame, BTAgent* agent)
+		{
+			var nodesAndStatus = frame.ResolveList(agent->NodesStatus);
+			return (BTStatus)nodesAndStatus[Id];
+		}
+
+		public void SetStatus(Frame frame, BTStatus status, BTAgent* agent)
+		{
+			var nodesAndStatus = frame.ResolveList(agent->NodesStatus);
+			nodesAndStatus[Id] = (Byte)status;
+		}
+
+		/// <summary>
+		/// Called whenever the BT execution includes this node as part of the current context
+		/// </summary>
+		/// <param name="btParams"></param>
+		public virtual void OnEnter(BTParams btParams) { }
+
+		public virtual void OnEnterRunning(BTParams btParams) { }
+
+		/// <summary>
+		/// Called when traversing the tree upwards and the node is already finished with its job.
+		/// Used by Composites and Leafs to remove their Services from the list of active services
+		/// as it is not anymore part of the current subtree.
+		/// Dynamic Composites also remove themselves
+		/// </summary>
+		/// <param name="btParams"></param>
+		public virtual void OnExit(BTParams btParams) { }
+
+		public virtual void OnAbort(BTParams btParams)
+		{
+		}
+
+		/// <summary>
+		/// Called when getting out of a sub-branch and this node is being discarded
+		/// </summary>
+		/// <param name="btParams"></param>
+		public unsafe virtual void OnReset(BTParams btParams)
+		{
+			SetStatus(btParams.Frame, BTStatus.Inactive, btParams.Agent);
+		}
+
+		public void EvaluateAbortNode(BTParams btParams)
+		{
+			if (btParams.Agent->AbortNodeId == Id)
+			{
+				btParams.Agent->AbortNodeId = 0;
+			}
+		}
+
+		public BTStatus RunUpdate(BTParams btParams, bool continuingAbort = false)
+		{
+			var oldStatus = GetStatus(btParams.Frame, btParams.Agent);
+
+			if (oldStatus == BTStatus.Success || oldStatus == BTStatus.Failure)
+			{
+				return oldStatus;
+			}
+
+			if (oldStatus == BTStatus.Abort)
+			{
+				if (btParams.Agent->IsAborting == true)
+				{
+					EvaluateAbortNode(btParams);
+				}
+				return oldStatus;
+			}
+
+			// If this node was inactive, this means that we're entering on it for the first time, so we call OnEnter
+			// An exception from this rule is when we chose this node to continue an abort process. In that case,
+			// we already executed OnEnter before, so we don't repeat it
+			if (oldStatus == BTStatus.Inactive && continuingAbort == false)
+			{
+				OnEnter(btParams);
+			}
+
+			var newStatus = BTStatus.Failure;
+			try
+			{
+				newStatus = OnUpdate(btParams);
+
+				if (btParams.Agent->IsAborting)
+				{
+					newStatus = BTStatus.Abort;
+				}
+
+				// Used for debugging purposes
+				if (newStatus == BTStatus.Success)
+				{
+					BTManager.OnNodeSuccess?.Invoke(btParams.Entity, Guid.Value);
+					BTManager.OnNodeExit?.Invoke(btParams.Entity, Guid.Value);
+				}
+
+				if (newStatus == BTStatus.Failure)
+				{
+					BTManager.OnNodeFailure?.Invoke(btParams.Entity, Guid.Value);
+					BTManager.OnNodeExit?.Invoke(btParams.Entity, Guid.Value);
+				}
+			}
+			catch (Exception e)
+			{
+				Log.Error("Exception in Behaviour Tree node '{0}' ({1}) - setting node status to Failure", Label, Guid);
+				Log.Exception(e);
+			}
+
+			SetStatus(btParams.Frame, newStatus, btParams.Agent);
+
+			if ((newStatus == BTStatus.Running || newStatus == BTStatus.Success) &&
+					(oldStatus == BTStatus.Failure || oldStatus == BTStatus.Inactive))
+			{
+				OnEnterRunning(btParams);
+			}
+
+			if (newStatus == BTStatus.Running && NodeType == BTNodeType.Leaf)
+			{
+				// If we are a leaf, we can store the current node
+				// We know that there has only one leaf node running at any time, no parallel branches possible
+				// The Run() method also return a tuple <BTStatus, BTNode(CurrentNode)>
+				btParams.Agent->Current = this;
+			}
+
+			return newStatus;
+		}
+
+		/// <summary>
+		/// Used by Decorators to evaluate if a condition succeeds or not.
+		/// Upon success, allow the flow to continue.
+		/// Upon failure, blocks the execution so another path is taken
+		/// </summary>
+		/// <param name="btParams"></param>
+		/// <returns></returns>
+		public virtual Boolean DryRun(BTParams btParams)
+		{
+			return false;
+		}
+
+		public virtual Boolean OnDynamicRun(BTParams btParams)
+		{
+			return true;
+		}
+
+		/// <summary>
+		/// Called every tick while this Node is part of the current sub-tree.
+		/// Returning "Success/Failure" will make the tree continue its execution.
+		/// Returning "Running" will store this Node as the Current Node and re-execute it on the next frame
+		/// unless something else interrputs
+		/// </summary>
+		/// <param name="btParams"></param>
+		/// <returns></returns>
+		protected abstract BTStatus OnUpdate(BTParams btParams);
+	}
+}

data/BTNodeType.cs

@@ -0,0 +1,11 @@
+namespace Quantum
+{
+	public enum BTNodeType
+	{
+		Root,
+		Leaf,
+		Decorator,
+		Composite,
+		Service
+	}
+}

data/BTParams.cs

@@ -0,0 +1,44 @@
+using System.Runtime.InteropServices;
+
+namespace Quantum
+{
+	[StructLayout(LayoutKind.Auto)]
+	public unsafe partial struct BTParams
+	{
+		private Frame _frame;
+		private BTAgent* _agent;
+		private EntityRef _entity;
+		private AIBlackboardComponent* _blackboard;
+
+		private BTParamsUser _userParams;
+
+		public Frame Frame { get => _frame; }
+		public BTAgent* Agent { get => _agent; }
+		public EntityRef Entity { get => _entity; }
+		public AIBlackboardComponent* Blackboard { get => _blackboard; }
+
+		public BTParamsUser UserParams { get => _userParams; set => _userParams = value; }
+
+		public void SetDefaultParams(Frame frame, BTAgent* agent, EntityRef entity, AIBlackboardComponent* blackboard = null)
+		{
+			_frame = frame;
+			_agent = agent;
+			_entity = entity;
+			_blackboard = blackboard;
+		}
+
+		public void Reset(Frame frame)
+		{
+			_frame = default;
+			_agent = default;
+			_entity = default;
+			_blackboard = default;
+
+			_userParams = default;
+		}
+	}
+
+	public partial struct BTParamsUser
+	{
+	}
+}

data/BTRoot.cs

@@ -0,0 +1,58 @@
+using Photon.Deterministic;
+using System;
+using System.Collections.Generic;
+
+namespace Quantum
+{
+	[Serializable]
+	public unsafe partial class BTRoot : BTDecorator
+	{
+		[BotSDKHidden] public Int32 NodesAmount;
+
+		public override BTNodeType NodeType
+		{
+			get
+			{
+				return BTNodeType.Root;
+			}
+		}
+
+		protected unsafe override BTStatus OnUpdate(BTParams btParams)
+		{
+
+			btParams.Agent->Current = this;
+
+			if (_childInstance != null)
+			{
+				return _childInstance.RunUpdate(btParams);
+			}
+
+			return BTStatus.Success;
+		}
+
+		public void InitializeTree(Frame frame, BTAgent* agent, AIBlackboardComponent* blackboard)
+		{
+			InitNodesRecursively(frame, this, agent, blackboard);
+		}
+
+		private static void InitNodesRecursively(Frame frame, BTNode node, BTAgent* agent, AIBlackboardComponent* blackboard)
+		{
+			node.Init(frame, blackboard, agent);
+
+			if (node is BTDecorator decoratorNode)
+			{
+				BTNode childNode = frame.FindAsset<BTNode>(decoratorNode.Child.Id);
+				InitNodesRecursively(frame, childNode, agent, blackboard);
+			}
+
+			if (node is BTComposite compositeNode)
+			{
+				foreach (var child in compositeNode.Children)
+				{
+					BTNode childNode = frame.FindAsset<BTNode>(child.Id);
+					InitNodesRecursively(frame, childNode, agent, blackboard);
+				}
+			}
+		}
+	}
+}

data/BTSelector.cs

@@ -0,0 +1,64 @@
+using System;
+
+namespace Quantum
+{
+
+	/// <summary>
+	/// The selector task is similar to an or operation. It will return success as soon as one of its child tasks return success.
+	/// If a child task returns failure then it will sequentially run the next task. If no child task returns success then it will return failure.
+	/// </summary>
+	[Serializable]
+	public unsafe partial class BTSelector : BTComposite
+	{
+		protected override BTStatus OnUpdate(BTParams btParams)
+		{
+			BTStatus status = BTStatus.Success;
+
+			while (GetCurrentChild(btParams.Frame, btParams.Agent) < _childInstances.Length)
+			{
+				var currentChildId = GetCurrentChild(btParams.Frame, btParams.Agent);
+				var child = _childInstances[currentChildId];
+				status = child.RunUpdate(btParams);
+
+				if (status == BTStatus.Abort && btParams.Agent->IsAborting == true)
+				{
+					return BTStatus.Abort;
+				}
+
+				if (status == BTStatus.Failure || status == BTStatus.Abort)
+				{
+					SetCurrentChild(btParams.Frame, currentChildId + 1, btParams.Agent);
+				}
+				else
+					break;
+			}
+
+			return status;
+		}
+
+		internal override void ChildCompletedRunning(BTParams btParams, BTStatus childResult)
+		{
+			if (childResult == BTStatus.Abort)
+			{
+				return;
+			}
+
+			if (childResult == BTStatus.Failure)
+			{
+				var currentChild = GetCurrentChild(btParams.Frame, btParams.Agent);
+				SetCurrentChild(btParams.Frame, currentChild + 1, btParams.Agent);
+			}
+			else
+			{
+				SetCurrentChild(btParams.Frame, _childInstances.Length, btParams.Agent);
+
+				// If the child succeeded, then we already know that this sequence succeeded, so we can force it
+				SetStatus(btParams.Frame, BTStatus.Success, btParams.Agent);
+
+				// Trigger the debugging callbacks
+				BTManager.OnNodeSuccess?.Invoke(btParams.Entity, Guid.Value);
+				BTManager.OnNodeExit?.Invoke(btParams.Entity, Guid.Value);
+			}
+		}
+	}
+}

data/BTSequence.cs

@@ -0,0 +1,72 @@
+using System;
+
+namespace Quantum
+{
+	/// <summary>
+	/// The sequence task is similar to an and operation. It will return failure as soon as one of its child tasks return failure.
+	/// If a child task returns success then it will sequentially run the next task. If all child tasks return success then it will return success.
+	/// </summary>
+	[Serializable]
+	public unsafe partial class BTSequence : BTComposite
+	{
+		protected override BTStatus OnUpdate(BTParams btParams)
+		{
+			BTStatus status = BTStatus.Success;
+
+			while (GetCurrentChild(btParams.Frame, btParams.Agent) < _childInstances.Length)
+			{
+				var currentChildId = GetCurrentChild(btParams.Frame, btParams.Agent);
+				var child = _childInstances[currentChildId];
+				status = child.RunUpdate(btParams);
+
+				if (status == BTStatus.Abort)
+				{
+					if (btParams.Agent->IsAborting == true)
+					{
+						return BTStatus.Abort;
+					}
+					else
+					{
+						return BTStatus.Failure;
+					}
+				}
+
+				if (status == BTStatus.Success)
+				{
+					SetCurrentChild(btParams.Frame, currentChildId + 1, btParams.Agent);
+				}
+				else
+				{
+					break;
+				}
+			}
+
+			return status;
+		}
+
+		internal override void ChildCompletedRunning(BTParams btParams, BTStatus childResult)
+		{
+			if (childResult == BTStatus.Abort)
+			{
+				return;
+			}
+
+			if (childResult == BTStatus.Failure)
+			{
+				SetCurrentChild(btParams.Frame, _childInstances.Length, btParams.Agent);
+
+				// If the child failed, then we already know that this sequence failed, so we can force it
+				SetStatus(btParams.Frame, BTStatus.Failure, btParams.Agent);
+
+				// Trigger the debugging callbacks
+				BTManager.OnNodeFailure?.Invoke(btParams.Entity, Guid.Value);
+				BTManager.OnNodeExit?.Invoke(btParams.Entity, Guid.Value);
+			}
+			else
+			{
+				var currentChild = GetCurrentChild(btParams.Frame, btParams.Agent);
+				SetCurrentChild(btParams.Frame, currentChild + 1, btParams.Agent);
+			}
+		}
+	}
+}

data/BTService.cs

@@ -0,0 +1,70 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	public unsafe abstract partial class BTService
+	{
+		public FP IntervalInSec;
+
+		[BotSDKHidden] public Int32 Id;
+
+		public virtual void Init(Frame frame, BTAgent* agent, AIBlackboardComponent* blackboard)
+		{
+			var endTimesList = frame.ResolveList<FP>(agent->ServicesEndTimes);
+			endTimesList.Add(0);
+		}
+
+		public void SetEndTime(Frame frame, BTAgent* agent)
+		{
+			var endTimesList = frame.ResolveList<FP>(agent->ServicesEndTimes);
+			endTimesList[Id] = frame.BotSDKGameTime + IntervalInSec;
+		}
+
+		public FP GetEndTime(Frame frame, BTAgent* agent)
+		{
+			var endTime = frame.ResolveList(agent->ServicesEndTimes);
+			return endTime[Id];
+		}
+
+		public virtual void RunUpdate(BTParams btParams)
+		{
+			var endTime = GetEndTime(btParams.Frame, btParams.Agent);
+			if (btParams.Frame.BotSDKGameTime >= endTime)
+			{
+				OnUpdate(btParams);
+				SetEndTime(btParams.Frame, btParams.Agent);
+			}
+		}
+
+		public virtual void OnEnter(BTParams btParams)
+		{
+			SetEndTime(btParams.Frame, btParams.Agent);
+		}
+
+		/// <summary>
+		/// Called whenever the Service is part of the current subtree
+		/// and its waiting time is already over
+		/// </summary>
+		protected abstract void OnUpdate(BTParams btParams);
+
+		public static void TickServices(BTParams btParams)
+		{
+			var activeServicesList = btParams.Frame.ResolveList<AssetRefBTService>(btParams.Agent->ActiveServices);
+
+			for (int i = 0; i < activeServicesList.Count; i++)
+			{
+				var service = btParams.Frame.FindAsset<BTService>(activeServicesList[i].Id);
+				try
+				{
+					service.RunUpdate(btParams);
+				}
+				catch (Exception e)
+				{
+					Log.Error("Exception in Behaviour Tree service '{0}' ({1}) - setting node status to Failure", service.GetType().ToString(), service.Guid);
+					Log.Exception(e);
+				}
+			}
+		}
+	}
+}

data/BTStatus.cs

@@ -0,0 +1,11 @@
+namespace Quantum
+{
+	public enum BTStatus
+	{
+		Inactive,
+		Success,
+		Failure,
+		Running,
+		Abort
+	}
+}

data/BallPoolSpec.cs

@@ -0,0 +1,14 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  unsafe partial class BallPoolSpec
+  {
+    public FP SpinMultiplier;
+    public FP EndOfMovementVelocityThreshold;
+    public Int32 EndOfMovementWaitingInTicks;
+
+    public Int32 Layer { get; set; }
+  }
+}

data/BehaviourTree.Manager.cs

@@ -0,0 +1,76 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	public static unsafe partial class BTManager
+	{
+		public static Action<EntityRef, string> OnSetupDebugger;
+
+		public static Action<EntityRef, long> OnNodeEnter;
+		public static Action<EntityRef, long> OnNodeExit;
+		public static Action<EntityRef, long> OnNodeSuccess;
+		public static Action<EntityRef, long> OnNodeFailure;
+		public static Action<EntityRef, long, bool> OnDecoratorChecked;
+		public static Action<EntityRef, long> OnDecoratorReset;
+		public static Action<EntityRef> OnTreeCompleted;
+
+		/// <summary>
+		/// Call this once, to initialize the BTAgent.
+		/// This method internally looks for a Blackboard Component on the entity
+		/// and passes it down the pipeline.
+		/// </summary>
+		/// <param name="frame"></param>
+		/// <param name="entity"></param>
+		/// <param name="root"></param>
+		public static void Init(Frame frame, EntityRef entity, BTRoot root)
+		{
+			if (frame.Unsafe.TryGetPointer(entity, out BTAgent* agent))
+			{
+				agent->Initialize(frame, entity, agent, root, true);
+			}
+			else
+			{
+				Log.Error("[Bot SDK] Tried to initialize an entity which has no BTAgent component");
+			}
+		}
+
+		/// <summary>
+		/// Made for internal use only.
+		/// </summary>
+		public static void ClearBTParams(BTParams btParams)
+		{
+			btParams.Reset(btParams.Frame);
+		}
+
+		/// <summary>
+		/// Call this method every frame to update your BT Agent.
+		/// You can optionally pass a Blackboard Component to it, if your Agent use it
+		/// </summary>
+		public static void Update(Frame frame, EntityRef entity, AIBlackboardComponent* blackboard = null)
+		{
+			var agent = frame.Unsafe.GetPointer<BTAgent>(entity);
+			BTParams btParams = new BTParams();
+			btParams.SetDefaultParams(frame, agent, entity, blackboard);
+
+			agent->Update(ref btParams);
+		}
+
+		/// <summary>
+		/// CAUTION: Use this overload with care.<br/>
+		/// It allows the definition of custom parameters which are passed through the entire BT pipeline, for easy access.<br/>
+		/// The user parameters struct needs to be created from scratch every time BEFORE calling the BT Update method.<br/>
+		/// Make sure to also implement BTParamsUser.ClearUser(frame).
+		/// </summary>
+		/// <param name="userParams">Used to define custom user data. It needs to be created from scratch every time before calling this method.</param>
+		public static void Update(Frame frame, EntityRef entity, ref BTParamsUser userParams, AIBlackboardComponent* blackboard = null)
+		{
+			var agent = frame.Unsafe.GetPointer<BTAgent>(entity);
+			BTParams btParams = new BTParams();
+			btParams.SetDefaultParams(frame, agent, entity, blackboard);
+			btParams.UserParams = userParams;
+
+			agent->Update(ref btParams);
+		}
+	}
+}

data/Blackboard.qtn

@@ -0,0 +1,23 @@
+asset AIBlackboard;
+asset AIBlackboardInitializer;
+
+union BlackboardValue {
+	QBoolean BooleanValue;
+	byte ByteValue;
+	Int32 IntegerValue;
+	FP FPValue;
+	FPVector2 FPVector2Value;
+	FPVector3 FPVector3Value;
+	entity_ref EntityRefValue;
+}
+
+component AIBlackboardComponent {
+	asset_ref<AIBlackboard> Board;
+	list<BlackboardEntry> Entries;
+}
+
+
+struct BlackboardEntry{
+	BlackboardValue Value;
+	list<AssetRefBTDecorator> ReactiveDecorators;
+}

data/BlackboardEntry.cs

@@ -0,0 +1,36 @@
+using Quantum.Collections;
+
+namespace Quantum
+{
+	public unsafe partial struct BlackboardEntry
+	{
+		/// <summary>
+		/// Iterate through all Decorators that watches this Blackboard entry
+		/// Re-check the Decorators so it can check if an abort is needed
+		/// </summary>
+		/// <param name="btParams"></param>
+		public void TriggerDecorators(BTParams btParams)
+		{
+			var frame = btParams.Frame;
+
+			// If the reactive decorators list was already allocated...
+			if (ReactiveDecorators.Ptr != default)
+			{
+				// Solve it and trigger the decorators checks
+				var reactiveDecorators = frame.ResolveList(ReactiveDecorators);
+				for (int i = 0; i < reactiveDecorators.Count; i++)
+				{
+					var reactiveDecoratorRef = reactiveDecorators[i];
+					var decoratorInstance = frame.FindAsset<BTDecorator>(reactiveDecoratorRef.Id);
+					btParams.Agent->OnDecoratorReaction(btParams, decoratorInstance, decoratorInstance.AbortType, out bool abortSelf, out bool abortLowerPriority);
+
+					// If at least one Decorator resulted in abort, we stop and return already
+					if (abortSelf == true)
+					{
+						btParams.Agent->AbortNodeId = decoratorInstance.Id;
+					}
+				}
+			}
+		}
+	}
+}

data/BlackboardValue.cs

@@ -0,0 +1,42 @@
+using System;
+
+namespace Quantum
+{
+	public unsafe partial struct BlackboardValue
+	{
+		public String ValueToString()
+		{
+			switch (Field)
+			{
+				case BlackboardValue.BOOLEANVALUE: return string.Format("{0}", _BooleanValue);
+				case BlackboardValue.BYTEVALUE: return string.Format("{0}", _ByteValue);
+				case BlackboardValue.INTEGERVALUE: return string.Format("{0}", _IntegerValue);
+				case BlackboardValue.FPVALUE: return string.Format("{0}", _FPValue);
+				case BlackboardValue.FPVECTOR2VALUE: return string.Format("{0}", _FPVector2Value);
+				case BlackboardValue.FPVECTOR3VALUE: return string.Format("{0}", _FPVector3Value);
+				case BlackboardValue.ENTITYREFVALUE: return string.Format("{0}", _EntityRefValue);
+			}
+
+			return base.ToString();
+		}
+	}
+
+	public unsafe partial struct BlackboardValue
+	{
+		public String TypeToString()
+		{
+			switch (Field)
+			{
+				case BlackboardValue.BOOLEANVALUE: return "Boolean";
+				case BlackboardValue.BYTEVALUE: return "Byte";
+				case BlackboardValue.INTEGERVALUE: return "Integer";
+				case BlackboardValue.FPVALUE: return "FP";
+				case BlackboardValue.FPVECTOR2VALUE: return "Vector2";
+				case BlackboardValue.FPVECTOR3VALUE: return "Vector3";
+				case BlackboardValue.ENTITYREFVALUE: return "EntityRef";
+			}
+
+			return base.ToString();
+		}
+	}
+}