Upload 84 files

data/HFSM.TrueDecision.cs

@@ -0,0 +1,15 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	[Serializable]
+	[AssetObjectConfig(GenerateLinkingScripts = true, GenerateAssetCreateMenu = false, GenerateAssetResetMethod = false)]
+	public partial class TrueDecision : HFSMDecision
+	{
+		public override unsafe bool Decide(Frame frame, EntityRef entity)
+		{
+			return true;
+		}
+	}
+}

data/IBotDebug.cs

@@ -0,0 +1,15 @@
+namespace Quantum
+{
+	// Interface to make the communication between the three solutions involved: quantum_unity, quantum_code and quantum.ai.editor
+	// Basically, these are the information that the quantum.ai.editor needs to know that are meant to be filed from Unity
+	public interface IBotDebug
+	{
+		EntityRef EntityRef { get; }
+		Frame Frame { get; }
+
+		// The asset names on Unity
+		string GetHFSMRootName();
+		string GetBTRootName();
+		string GetUTRootName();
+	}
+}

data/IdleAction.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Runtime.InteropServices;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	[Serializable]
+	[AssetObjectConfig(GenerateLinkingScripts = true, GenerateAssetCreateMenu = false, GenerateAssetResetMethod = false)]
+	public partial class IdleAction : AIAction
+	{
+		public override unsafe void Update(Frame frame, EntityRef entity)
+		{
+		}
+	}
+}

data/IncreaseBlackboardInt.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace Quantum
+{
+	[Serializable]
+	[AssetObjectConfig(GenerateLinkingScripts = true, GenerateAssetCreateMenu = false, GenerateAssetResetMethod = false)]
+	public unsafe partial class IncreaseBlackboardInt : AIAction
+	{
+		public AIBlackboardValueKey Key;
+		public AIParamInt IncrementAmount;
+
+		public override unsafe void Update(Frame frame, EntityRef entity)
+		{
+			var blackboard = frame.Unsafe.GetPointer<AIBlackboardComponent>(entity);
+
+			var agent = frame.Unsafe.GetPointer<HFSMAgent>(entity);
+			var aiConfig = agent->GetConfig(frame);
+
+			var incrementValue = IncrementAmount.Resolve(frame, entity, blackboard, aiConfig);
+
+			var currentAmount = blackboard->GetInteger(frame, Key.Key);
+			currentAmount += incrementValue;
+
+			blackboard->Set(frame, Key.Key, currentAmount);
+		}
+	}
+}

data/Input.User.cs

@@ -0,0 +1,29 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  unsafe partial struct Input
+  {
+    // input bandwidth trick by Erick Passos
+    // using a single Byte to encode a 2D direction with 2 degrees of accuracy
+    public FPVector2 Direction
+    {
+      get {
+        if (EncodedDirection == default) return default;
+        Int32 angle = ((Int32)EncodedDirection - 1) * 2;
+        return FPVector2.Rotate(FPVector2.Up, angle * FP.Deg2Rad);
+      }
+      set {
+        if (value == default)
+        {
+          EncodedDirection = default;
+          return;
+        }
+        var angle = FPVector2.RadiansSigned(FPVector2.Up, value) * FP.Rad2Deg;
+        angle = (((angle + 360) % 360) / 2) + 1;
+        EncodedDirection = (Byte)(angle.AsInt);
+      }
+    }
+  }
+}

data/InputHandler.cs

@@ -0,0 +1,74 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Quantum;
+using Photon.Deterministic;
+
+public unsafe class InputHandler : MonoBehaviour
+{
+
+  public int InitialIndex;
+  public int TargetIndex;
+  public bool HasInitial;
+  public bool DebugMoves = false;
+  public MovesIndicatorManager MovesIndicator;
+  public GameObject SelectedPieceIndicator;
+
+  public UnityEngine.LayerMask BoardsRaycastMask;
+
+  private void Update()
+  {
+    HandleClick();
+
+    if (HasInitial)
+    {
+      ChessViewUpdater.Instance.SetObjectByIndex(SelectedPieceIndicator, InitialIndex);
+    }
+    else {
+      SelectedPieceIndicator.SetActive(false);
+    }
+  }
+
+  public void HandleClick()
+  {
+    if (UnityEngine.Input.GetMouseButtonDown(0))
+    {
+      // Perform the Unity raycast
+      Ray ray = Camera.main.ScreenPointToRay(UnityEngine.Input.mousePosition);
+      RaycastHit hit;
+      Physics.Raycast(ray, out hit, 100, BoardsRaycastMask);
+
+      // If the raycast hit the Board...
+      if (hit.collider != null)
+      {
+        var position = new FPVector2(FP.FromFloat_UNSAFE(hit.point.x), FP.FromFloat_UNSAFE(hit.point.z));
+        if (HasInitial == false || DebugMoves)
+        {
+          InitialIndex = BoardHelper.GetIndexByPosition(position);
+          HasInitial = true;
+          MovesIndicator.UpdatePossibleMovements(InitialIndex);
+        }
+        else
+        {
+          TargetIndex = BoardHelper.GetIndexByPosition(position);
+          Frame f = QuantumRunner.Default.Game.Frames.Verified;
+          if (MoveValidatorHelper.IsValidMove(ref f.Global->Board, InitialIndex, TargetIndex, true) == false)
+          {
+            InitialIndex = TargetIndex;
+            MovesIndicator.UpdatePossibleMovements(InitialIndex);
+          }
+          else
+          {
+            HasInitial = false;
+            //sendcommand
+            var c = new MoveCommand();
+            c.Data.InitialIndex = InitialIndex;
+            c.Data.TargetIndex = TargetIndex;
+            QuantumRunner.Default.Game.SendCommand(c);
+            MovesIndicator.ResetPrefabs();
+          }
+        }
+      }
+    }
+  }
+}

data/KCCSettings.txt

@@ -0,0 +1,194 @@
+using System;
+using Photon.Deterministic;
+using Quantum.Core;
+
+namespace Quantum
+{
+	public enum KCCMovementType
+	{
+		None,
+		Free,
+		Tangent
+	}
+
+	public struct KCCMovementData
+	{
+		public KCCMovementType Type;
+		public FPVector2 Correction;
+		public FPVector2 Direction;
+		public FP MaxPenetration;
+	}
+
+	unsafe partial class KCCSettings : AssetObject
+	{
+		// This is the KCC actual radius (non penetrable)
+		public FP Radius = FP._0_50;
+		public Int32 MaxContacts = 2;
+		public FP AllowedPenetration = FP._0_10;
+		public FP CorrectionSpeed = FP._10;
+		public FP BaseSpeed = FP._2;
+		public FP Acceleration = FP._10;
+		public Boolean Debug = false;
+		public FP Brake = 1;
+
+		public void Init(ref KCC kcc)
+		{
+			kcc.Settings = this;
+			kcc.MaxSpeed = BaseSpeed;
+			kcc.Acceleration = Acceleration;
+		}
+
+		public void SteerAndMove(FrameBase f, EntityRef entity, in KCCMovementData movementData)
+		{
+			KCC* kcc = null;
+			if (f.Unsafe.TryGetPointer(entity, out kcc) == false)
+			{
+				return;
+			}
+
+			Transform2D* transform = null;
+			if (f.Unsafe.TryGetPointer(entity, out transform) == false)
+			{
+				return;
+			}
+
+			if (movementData.Type != KCCMovementType.None)
+			{
+				kcc->Velocity += kcc->Acceleration * f.DeltaTime * movementData.Direction;
+				if (kcc->Velocity.SqrMagnitude > kcc->MaxSpeed * kcc->MaxSpeed)
+				{
+					kcc->Velocity = kcc->Velocity.Normalized * kcc->MaxSpeed;
+				}
+				//transform->Rotation = FPVector2.RadiansSigned(FPVector2.Up, movementData.Direction);// FPMath.Atan2(kcc->Velocity.Y, kcc->Velocity.X);
+			}
+			else
+			{
+				// brake instead?
+				kcc->Velocity = FPVector2.MoveTowards(kcc->Velocity, FPVector2.Zero, f.DeltaTime * Brake);
+			}
+
+			if (movementData.MaxPenetration > AllowedPenetration)
+			{
+				if (movementData.MaxPenetration > AllowedPenetration * 2)
+				{
+					transform->Position += movementData.Correction;
+				}
+				else
+				{
+					transform->Position += movementData.Correction * f.DeltaTime * CorrectionSpeed;
+				}
+
+			}
+
+
+			transform->Position += kcc->Velocity * f.DeltaTime;
+
+
+
+#if DEBUG
+			if (Debug)
+			{
+				Draw.Circle(transform->Position, Radius, ColorRGBA.Blue);
+				Draw.Ray(transform->Position, transform->Forward * Radius, ColorRGBA.Red);
+			}
+#endif
+		}
+
+		public KCCMovementData ComputeRawMovement(FrameBase f, EntityRef entity, FPVector2 direction)
+		{
+			KCC* kcc = null;
+			if (f.Unsafe.TryGetPointer(entity, out kcc) == false)
+			{
+				return default;
+			}
+
+			Transform2D* transform = null;
+			if (f.Exists(entity) == false || f.Unsafe.TryGetPointer(entity, out transform) == false)
+			{
+				return default;
+			}
+
+			KCCMovementData movementPack = default;
+
+
+			movementPack.Type = direction != default ? KCCMovementType.Free : KCCMovementType.None;
+			movementPack.Direction = direction;
+			Shape2D shape = Shape2D.CreateCircle(Radius);
+
+			var layer = f.Layers.GetLayerMask("Static");
+			var hits = f.Physics2D.OverlapShape(transform->Position, FP._0, shape, layer, options: QueryOptions.HitStatics | QueryOptions.ComputeDetailedInfo);
+			int count = Math.Min(MaxContacts, hits.Count);
+
+			if (hits.Count > 0)
+			{
+				Boolean initialized = false;
+				hits.Sort(transform->Position);
+				for (int i = 0; i < hits.Count && count > 0; i++)
+				{
+					// ignore triggers
+					if (hits[i].IsTrigger)
+					{
+						// callback here...
+						continue;
+					}
+
+					// ignoring "self" contact
+					if (hits[i].Entity == entity)
+					{
+						continue;
+					}
+
+					var contactPoint = hits[i].Point;
+					var contactToCenter = transform->Position - contactPoint;
+					var localDiff = contactToCenter.Magnitude - Radius;
+
+
+#if DEBUG
+					if (Debug)
+					{
+						Draw.Circle(contactPoint, FP._0_10, ColorRGBA.Red);
+					}
+#endif
+
+					var localNormal = contactToCenter.Normalized;
+
+					count--;
+
+					// define movement type
+					if (!initialized)
+					{
+						initialized = true;
+
+						if (direction != default)
+						{
+							var angle = FPVector2.RadiansSkipNormalize(direction.Normalized, localNormal);
+							if (angle >= FP.Rad_90)
+							{
+								var d = FPVector2.Dot(direction, localNormal);
+								var tangentVelocity = direction - localNormal * d;
+								if (tangentVelocity.SqrMagnitude > FP.EN4)
+								{
+									movementPack.Direction = tangentVelocity.Normalized;
+									movementPack.Type = KCCMovementType.Tangent;
+								}
+								else
+								{
+									movementPack.Direction = default;
+									movementPack.Type = KCCMovementType.None;
+								}
+
+							}
+						}
+						movementPack.MaxPenetration = FPMath.Abs(localDiff);
+					}
+
+					// any real contact contributes to correction and average normal
+					var localCorrection = localNormal * -localDiff;
+					movementPack.Correction += localCorrection;
+				}
+			}
+
+			return movementPack;
+		}
+	}
+}

data/Lists.txt

@@ -0,0 +1,12 @@
+
+In quantum we can to list as metioned below.
+we can to list in Quantum by the following
+
+component Targets {
+  list<EntityRef> Enemies;
+}
+The basic API methods for dealing with these Lists are:
+
+Frame.AllocateList<T>()
+Frame.FreeList(QListPtr<T> ptr)
+Frame.ResolveList(QListPtr<T> ptr)

data/Map.cs

@@ -0,0 +1 @@
+

data/MovesIndicatorManager.cs

@@ -0,0 +1,60 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Quantum;
+
+public unsafe class MovesIndicatorManager : QuantumCallbacks
+{
+
+  public GameObject HighlightPrefab;
+
+  private List<GameObject> _prefabs = new List<GameObject>();
+
+  public void UpdatePossibleMovements(int index)
+  {
+    var f = QuantumRunner.Default.Game.Frames.Verified;
+    ResetPrefabs();
+    for (int i = 0; i < f.Global->Board.Cells.Length; i++)
+    {
+      if (MoveValidatorHelper.IsValidMove(ref f.Global->Board, index, i, true))
+      {
+        var FPPosition = BoardHelper.GetCordinatesByIndex(i);
+        Vector3 position = new Vector3((float)FPPosition.X + .5f, .5f, (float)FPPosition.Y + .5f);
+        var prefab = GetPrefab();
+        if (prefab == null)
+        {
+          var go = Instantiate(HighlightPrefab, position, Quaternion.identity, transform);
+          go.SetActive(true);
+          _prefabs.Add(go);
+        }
+        else
+        {
+          prefab.SetActive(true);
+          prefab.transform.position = position;
+        }
+      }
+    }
+  }
+  private GameObject GetPrefab()
+  {
+    for (int i = 0; i < _prefabs.Count; i++)
+    {
+      if (_prefabs[i] != null && _prefabs[i].activeSelf == false)
+      {
+        return _prefabs[i];
+      }
+    }
+    return null;
+  }
+
+  public void ResetPrefabs()
+  {
+    for (int i = 0; i < _prefabs.Count; i++)
+    {
+      if (_prefabs[i] != null)
+      {
+        _prefabs[i].SetActive(false);
+      }
+    }
+  }
+}

data/PickupSpawnerSystem.cs

@@ -0,0 +1,35 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	public unsafe class PickupSpawnerSystem : SystemMainThread
+	{
+		public override void Update(Frame frame)
+		{
+			if (frame.Unsafe.TryGetPointerSingleton<PickupSpawner>(out var spawner))
+			{
+				int frameInterval = spawner->SpawnInterval * frame.UpdateRate;
+				//if ((frameInterval % f.Number) == 0 && spawner->Count < spawner->MaxCount)
+				if (spawner->Count < spawner->MaxCount)
+				{
+					EntityRef pickup = frame.Create(spawner->PickupPrototype);
+					if (frame.Unsafe.TryGetPointer<Transform3D>(pickup, out var transform))
+					{
+						FP angle = frame.RNG->Next(0, 360);
+						FPQuaternion rotation = FPQuaternion.Euler(0, angle, 0);
+						transform->Position = (rotation * FPVector3.Right) * frame.RNG->Next(FP._0, spawner->RandomRadius);
+					}
+					spawner->Count++;
+				}
+
+			}
+
+			ComponentIterator<ChainItem> chainItems = frame.GetComponentIterator<ChainItem>();
+			foreach (var item in chainItems)
+			{
+				if (item.Component.Destroy) frame.Destroy(item.Entity);
+			}
+		}
+	}
+}

data/PieceView.cs

@@ -0,0 +1,28 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Quantum;
+
+public class PieceView : MonoBehaviour {
+  public PieceType Type;
+  public PieceColor Color;
+  public int IndexOnBoard = -1;
+  public bool Initialized = false;
+
+  [SerializeField]
+  private Vector3 _targetPosition;
+
+  public void SetTargetPosition(Vector3 target)
+  {
+    Initialized = true;
+    _targetPosition = target;
+  }
+
+  void Update()
+  {
+    if (Vector3.Distance(transform.position, _targetPosition) > 0.01f && Initialized) {
+      transform.position = Vector3.Lerp(transform.position, _targetPosition, Time.deltaTime * 10);
+    }
+  }
+
+}

data/PiecesMapBaker.cs

@@ -0,0 +1,59 @@
+using UnityEngine;
+using Quantum;
+using Photon.Deterministic;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+//When a class implements MapDataBakerCallback, it can handle the activation of the "OnBake" event.
+//This event is called when you hit the "Bake Data" at the Unity scene
+//So this is useful whenever the developer needs to be into the bake process
+public class PiecesMapBaker : MapDataBakerCallback
+{
+  public override void OnBake(MapData data)
+  {
+    PieceView[] pieces = GameObject.FindObjectsOfType<PieceView>();
+
+    var boardSpec = UnityDB.FindAsset<BoardSpecAsset>(data.Asset.Settings.UserAsset.Id);
+    boardSpec.Settings.Pieces = new BoardSpec.PieceMap[pieces.Length];
+
+    FillBoardInformation(boardSpec.Settings, pieces);
+#if UNITY_EDITOR
+    EditorUtility.SetDirty(boardSpec.Settings.GetUnityAsset());
+#endif
+
+  }
+
+  public override void OnBeforeBake(MapData data)
+  {
+  }
+
+  private void FillBoardInformation(BoardSpec targetSpec, PieceView[] pieces)
+  {
+    for (int i = 0; i < targetSpec.Pieces.Length; i++)
+    {
+      targetSpec.Pieces[i].InitialIndex = -1;
+
+      targetSpec.Pieces[i].Type = PieceType.None;
+      targetSpec.Pieces[i].Color = PieceColor.None;
+    }
+
+    for (int i = 0; i < pieces.Length; i++)
+    {
+      FP positionX = FP.FromFloat_UNSAFE(pieces[i].transform.position.x);
+      FP positionY = FP.FromFloat_UNSAFE(pieces[i].transform.position.z);
+      var index = BoardHelper.GetIndexByPosition(new FPVector2(positionX, positionY));
+      if (index >= 0)
+      {
+        targetSpec.Pieces[i].InitialIndex = index;
+        pieces[i].IndexOnBoard = index;
+        targetSpec.Pieces[i].Type = pieces[i].Type;
+        targetSpec.Pieces[i].Color = pieces[i].Color;
+      }
+      else
+      {
+        pieces[i].IndexOnBoard = -1;
+      }
+    }
+  }
+}

data/PlayCommand.cs

@@ -0,0 +1,26 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  [Serializable]
+  public struct PlayCommandData
+  {
+    public FP Force;
+    public FPVector3 Direction;
+    public FPVector2 Spin;
+  }
+
+  public class PlayCommand : DeterministicCommand
+  {
+    public PlayCommandData Data;
+
+    public override void Serialize(BitStream stream)
+    {
+      // serialize command data here
+      stream.Serialize(ref Data.Force);
+      stream.Serialize(ref Data.Direction);
+      stream.Serialize(ref Data.Spin);
+    }
+  }
+}

data/PlayerSystem.cs

@@ -0,0 +1,25 @@
+using System;
+using Photon.Deterministic;
+using Quantum.Task;
+
+namespace Quantum
+{
+	public unsafe class PlayerSystem : SystemSignalsOnly, ISignalOnPlayerDataSet
+	{
+		public void OnPlayerDataSet(Frame frame, PlayerRef player)
+		{
+			RuntimePlayer data = frame.GetPlayerData(player);
+			EntityRef traktorEntity = frame.Create(data.TraktorPrototype);
+			Traktor* traktor = frame.Unsafe.GetPointer<Traktor>(traktorEntity);
+			if (frame.Unsafe.TryGetPointer<Transform3D>(traktorEntity, out var transform) && frame.Unsafe.TryGetPointer<Transform3D>(traktor->Sphere, out var sphereTransform))
+			{
+				transform->Position = new FPVector3(player * 2, 0, 0);
+				sphereTransform->Position = transform->Position;
+			}
+			if (frame.Unsafe.TryGetPointer<Controller>(traktorEntity, out var controller))
+			{
+				controller->Player = player;
+			}
+		}
+	}
+}

data/Pool.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace Quantum
+{
+	public static class Pool<T> where T : new()
+	{
+		private const int POOL_CAPACITY = 4;
+
+		private static readonly List<T> _pool = new List<T>(POOL_CAPACITY);
+
+		public static int Count => _pool.Count;
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static T Get()
+		{
+			bool found = false;
+			T item = default;
+
+			lock (_pool)
+			{
+				int index = _pool.Count - 1;
+				if (index >= 0)
+				{
+					found = true;
+					item = _pool[index];
+
+					_pool.RemoveAt(index);
+				}
+			}
+
+			if (found == false)
+			{
+				item = new T();
+			}
+
+			return item;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static void Return(T item)
+		{
+			if (item == null)
+				return;
+
+			lock (_pool)
+			{
+				_pool.Add(item);
+			}
+		}
+	}
+
+	public static class Pool
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static T Get<T>() where T : new()
+		{
+			return Pool<T>.Get();
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static void Return<T>(T item) where T : new()
+		{
+			Pool<T>.Return(item);
+		}
+	}
+}

data/QuantumConsoleRunner.cs

@@ -0,0 +1,29 @@
+using System;
+using System.IO;
+
+namespace Quantum {
+  class QuantumConsoleRunner {
+    static void Main(string[] args) {
+
+      Log.InitForConsole();
+
+      var pathToLUT = Path.GetFullPath(args[0]);
+      var pathToDatabaseFile = Path.GetFullPath(args[1]);
+      var pathToReplayFile = Path.GetFullPath(args[2]);
+      var pathToChecksumFile = args.Length > 3 ? Path.GetFullPath(args[3]) : null;
+      var maxIterations = args.Length > 4 ? long.Parse(args[4]) : 1;
+
+      // Demonstration of a sample runner. Please duplicate the ReplayRunnerSample class to modify, because it may get overwritten in the future.
+      long iteration = 0;
+      while (iteration < maxIterations && ReplayRunnerSample.Run(pathToLUT, pathToDatabaseFile, pathToReplayFile, pathToChecksumFile)) {
+        if (++iteration < maxIterations) {
+          Console.ForegroundColor = ConsoleColor.Blue;
+          Console.WriteLine($"Iteration {iteration + 1}");
+          Console.ForegroundColor = ConsoleColor.Gray;
+        }
+      }
+
+      //Console.ReadKey();
+    }
+  }
+}

data/QuantumJsonSerializer.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+
+namespace Quantum {
+
+  public class QuantumJsonSerializer : Quantum.JsonAssetSerializerBase {
+    private readonly JsonSerializer _serializer = CreateSerializer();
+
+    public static JsonSerializer CreateSerializer() {
+      return JsonSerializer.Create(CreateSettings());
+    }
+
+    protected override object FromJson(string json, Type type) {
+      using (var reader = new StringReader(json)) {
+        var result = _serializer.Deserialize(reader, type);
+        return result;
+      }
+    }
+
+    protected override string ToJson(object obj) {
+      using (var writer = new StringWriter()) {
+        _serializer.Serialize(writer, obj);
+        return writer.ToString();
+      }
+    }
+
+    private static JsonSerializerSettings CreateSettings() {
+      return new JsonSerializerSettings {
+        ContractResolver = new WritablePropertiesOnlyResolver(),
+        Formatting = Formatting.Indented,
+        TypeNameHandling = TypeNameHandling.Auto,
+        NullValueHandling = NullValueHandling.Ignore,
+        Converters = { new ByteArrayConverter() },
+      };
+    }
+    private class ByteArrayConverter : JsonConverter {
+
+      public override bool CanConvert(Type objectType) {
+        return objectType == typeof(byte[]);
+      }
+
+      public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) {
+        if (reader.TokenType == JsonToken.StartArray) {
+          var byteList = new List<byte>();
+
+          while (reader.Read()) {
+            switch (reader.TokenType) {
+              case JsonToken.Integer:
+                byteList.Add(Convert.ToByte(reader.Value));
+                break;
+
+              case JsonToken.EndArray:
+                return byteList.ToArray();
+
+              case JsonToken.Comment:
+                // skip
+                break;
+
+              default:
+                throw new Exception(string.Format("Unexpected token when reading bytes: {0}", reader.TokenType));
+            }
+          }
+
+          throw new Exception("Unexpected end when reading bytes.");
+        } else {
+          throw new Exception(string.Format("Unexpected token parsing binary. Expected StartArray, got {0}.", reader.TokenType));
+        }
+      }
+
+      public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) {
+        if (value == null) {
+          writer.WriteNull();
+          return;
+        }
+
+        byte[] data = (byte[])value;
+
+        // compose an array
+        writer.WriteStartArray();
+
+        for (var i = 0; i < data.Length; i++) {
+          writer.WriteValue(data[i]);
+        }
+
+        writer.WriteEndArray();
+      }
+    }
+
+    private class WritablePropertiesOnlyResolver : DefaultContractResolver {
+
+      protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization) {
+        IList<JsonProperty> props = base.CreateProperties(type, memberSerialization);
+        return props.Where(p => p.Writable).ToList();
+      }
+
+      protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) {
+        if (member is FieldInfo) {
+          // just fields
+          return base.CreateProperty(member, memberSerialization);
+        } else {
+          return null;
+        }
+      }
+    }
+  }
+}

data/ReplayJsonSerializerSettings.cs

@@ -0,0 +1,13 @@
+using Newtonsoft.Json;
+
+namespace Quantum {
+  public static class ReplayJsonSerializerSettings {
+    public static JsonSerializerSettings GetSettings() {
+      return new JsonSerializerSettings {
+        Formatting = Formatting.Indented,
+        TypeNameHandling = TypeNameHandling.Auto,
+        NullValueHandling = NullValueHandling.Ignore,
+      };
+    }
+  }
+}

data/ReplayRunnerSample.cs

@@ -0,0 +1,63 @@
+using Photon.Deterministic;
+using System;
+using System.IO;
+using System.Threading;
+
+namespace Quantum {
+  public class ReplayRunnerSample {
+
+    public static bool Run(string pathToLUT,string pathToDatabaseFile, string pathToReplayFile, string pathToChecksumFile) {
+
+      FPLut.Init(pathToLUT);
+
+      Console.WriteLine($"Loading replay from file: '{Path.GetFileName(pathToReplayFile)}' from folder '{Path.GetDirectoryName(pathToReplayFile)}'");
+
+      if (!File.Exists(pathToDatabaseFile)) {
+        Console.ForegroundColor = ConsoleColor.Red;
+        Console.WriteLine($"File not found: '{pathToReplayFile}'");
+        Console.ForegroundColor = ConsoleColor.Gray;
+        return false;
+      }
+
+      var serializer = new QuantumJsonSerializer();
+      var callbackDispatcher = new CallbackDispatcher();
+      var replayFile = serializer.DeserializeReplay(File.ReadAllBytes(pathToReplayFile));
+      var inputProvider = new InputProvider(replayFile.DeterministicConfig);
+      inputProvider.ImportFromList(replayFile.InputHistory);
+
+      var resourceManager = new ResourceManagerStatic(serializer.DeserializeAssets(File.ReadAllBytes(pathToDatabaseFile)), SessionContainer.CreateNativeAllocator());
+
+      var container = new SessionContainer(replayFile);
+      container.StartReplay(new QuantumGame.StartParameters {
+        AssetSerializer = serializer,
+        CallbackDispatcher = callbackDispatcher,
+        EventDispatcher = null,
+        ResourceManager = resourceManager,
+      }, inputProvider);
+
+      var numberOfFrames = replayFile.Length;
+      var checksumVerification = String.IsNullOrEmpty(pathToChecksumFile) ? null : new ChecksumVerification(pathToChecksumFile, callbackDispatcher);
+
+      while (container.Session.FramePredicted == null || container.Session.FramePredicted.Number < numberOfFrames) {
+        Thread.Sleep(1);
+        container.Service(dt: 1.0f);
+
+        if (Console.KeyAvailable) {
+          if (Console.ReadKey().Key == ConsoleKey.Escape) {
+            Console.WriteLine("Stopping replay");
+            return false;
+          }
+        }
+      }
+
+      Console.WriteLine($"Ending replay at frame {container.Session.FramePredicted.Number}");
+
+      checksumVerification?.Dispose();
+      container.Destroy();
+
+      resourceManager.Dispose();
+
+      return true;
+    }
+  }
+}

data/ResponseCurve.cs

@@ -0,0 +1,33 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	[BotSDKHidden]
+	[System.Serializable]
+	public unsafe partial class ResponseCurve : AIFunctionFP
+	{
+		public AIParamFP Input;
+
+		[BotSDKHidden]
+		public FPAnimationCurve Curve;
+
+		public override void Loaded(IResourceManager resourceManager, Native.Allocator allocator)
+		{
+			base.Loaded(resourceManager, allocator);
+		}
+
+		public override FP Execute(Frame frame, EntityRef entity = default)
+		{
+			if (Input.FunctionRef == default) return 0;
+
+			FP input = Input.ResolveFunction(frame, entity);
+			FP result = Curve.Evaluate(input);
+
+			if (result > 1) result = 1;
+			else if (result < 0) result = 0;
+
+			return result;
+		}
+	}
+}

data/RuntimeConfig.User.cs

@@ -0,0 +1,38 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	partial class RuntimeConfig
+	{
+		public bool ShowIntroduction;
+
+		public AssetRefHFSMRoot GameManagerHFSM;
+
+		public enum GameMode { CoinGrab, BossBattle };
+		public GameMode ConfigType = GameMode.CoinGrab;
+
+		public AssetRefEntityPrototype[] RoomFillBots;
+		public FP RoomFillInterval = 2;
+		public bool FillWithBots = true;
+
+		partial void SerializeUserData(BitStream stream)
+		{
+			stream.Serialize(ref ShowIntroduction);
+			stream.Serialize(ref GameManagerHFSM);
+
+			stream.SerializeArrayLength(ref RoomFillBots);
+			for (var i = 0; i < RoomFillBots.Length; i++)
+			{
+				stream.Serialize(ref RoomFillBots[i]);
+			}
+			stream.Serialize(ref RoomFillInterval);
+
+			Int32 current = (Int32)ConfigType;
+			stream.Serialize(ref current);
+			ConfigType = (GameMode)current;
+
+			stream.Serialize(ref FillWithBots);
+		}
+	}
+}

data/RuntimePlayer.User.cs

@@ -0,0 +1,24 @@
+using Photon.Deterministic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Quantum
+{
+	partial class RuntimePlayer
+	{
+		public AssetRefEntityPrototype SelectedCharacter;
+		public string PlayerName;
+		public bool ForceAI;
+		public int TeamIndex;
+
+		partial void SerializeUserData(BitStream stream)
+		{
+			stream.Serialize(ref SelectedCharacter);
+			stream.Serialize(ref PlayerName);
+			stream.Serialize(ref ForceAI);
+			stream.Serialize(ref TeamIndex);
+		}
+	}
+}

data/SelfDestroy.cs

@@ -0,0 +1,14 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class SelfDestroy : MonoBehaviour
+{
+  public float TTL = 2;
+
+  void Update()
+  {
+    if (TTL < 0) Destroy(gameObject);
+    TTL -= Time.deltaTime;
+  }
+}

data/SetBlackboardInt.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace Quantum
+{
+	[Serializable]
+	[AssetObjectConfig(GenerateLinkingScripts = true, GenerateAssetCreateMenu = false, GenerateAssetResetMethod = false)]
+	public unsafe partial class SetBlackboardInt : AIAction
+	{
+		public AIBlackboardValueKey Key;
+		public AIParamInt Value;
+
+		public override unsafe void Update(Frame frame, EntityRef entity)
+		{
+			var blackboard = frame.Unsafe.GetPointer<AIBlackboardComponent>(entity);
+
+			var agent = frame.Unsafe.GetPointer<HFSMAgent>(entity);
+			var aiConfig = agent->GetConfig(frame);
+
+			var value = Value.Resolve(frame, entity, blackboard, aiConfig);
+			blackboard->Set(frame, Key.Key, value);
+		}
+	}
+}

data/SimulationConfig.User.cs

@@ -0,0 +1,13 @@
+using Photon.Deterministic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Quantum
+{
+	partial class SimulationConfig : AssetObject
+	{
+
+	}
+}

data/SkipCommand.cs

@@ -0,0 +1,21 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  [Serializable]
+  public struct SkipCommandData
+  {
+    // game-specific command data here
+  }
+
+  public class SkipCommand : DeterministicCommand
+  {
+    public SkipCommandData Data;
+
+    public override void Serialize(BitStream stream)
+    {
+      // serialize command data here
+    }
+  }
+}

data/SpawnFX.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class SpawnFX : MonoBehaviour
+{
+  public Transform VFXPrefab;
+
+  private void OnDestroy()
+  {
+    Instantiate(VFXPrefab, transform.position, Quaternion.identity);
+  }
+}

data/StopwatchBlock.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Diagnostics;
+
+namespace Quantum
+{
+	public class StopwatchBlock : IDisposable
+	{
+		private Stopwatch _stopwatch;
+		private string _blockName;
+
+		public StopwatchBlock(string blockName)
+		{
+			_blockName = blockName;
+			_stopwatch = new Stopwatch();
+			_stopwatch.Start();
+		}
+
+		void IDisposable.Dispose()
+		{
+			_stopwatch.Stop();
+			Log.Info($"{_blockName}: {_stopwatch.Elapsed.TotalMilliseconds} ms");
+		}
+	}
+}

data/SystemSetup.cs

@@ -0,0 +1,56 @@
+using Photon.Deterministic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Quantum
+{
+	public static class SystemSetup
+	{
+		public static SystemBase[] CreateSystems(RuntimeConfig gameConfig, SimulationConfig simulationConfig)
+		{
+			return new SystemBase[] {
+        // pre-defined core systems
+        new Core.CullingSystem2D(),
+				new Core.CullingSystem3D(),
+
+				new Core.PhysicsSystem2D(),
+				new Core.PhysicsSystem3D(),
+
+#if DEBUG
+        Core.DebugCommand.CreateSystem(),
+#endif
+
+        new Core.NavigationSystem(),
+				new Core.EntityPrototypeSystem(),
+				new Core.PlayerConnectedSystem(),
+
+				new BotSDKDebuggerSystem(),
+
+				new GameplaySystemsGroup("Gameplay Systems",
+					new MatchSystem(),
+					new PlayerJoiningSystem(),
+					new CommandsSystem(),
+
+					new GameManagerSystem(),
+					new MemorySystem(),
+					new AISystem(),
+					new TeamDataSystem(),
+
+					new AttributesSystem(),
+					new HealthSystem(),
+					new ImmuneSystem(),
+					new VisibilitySystem(),
+					new InputSystem(),
+					new AttackSystem(),
+					new RespawnSystem(),
+					new SkillSystem()
+				),
+
+				// We don't add it to the group as it is a SignalsOnly system; no need to be enabled/disabled with the rest
+				new InventorySystem(),
+			};
+		}
+	}
+}

data/Traktor.User.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  
+  unsafe partial struct Traktor
+  {
+    public void Update(FrameThreadSafe frame, ref TraktorInputSystem.Filter filter, Input input)
+    {
+      TraktorConfig config = frame.FindAsset<TraktorConfig>(Config.Id);
+
+      ChainSystem.Filter sphereData = default;
+      var getter = frame.ComponentGetter<ChainSystem.Filter>();
+      ;
+      
+      if (getter.TryGet(frame, Sphere, &sphereData))
+      {
+        FPVector2 direction = input.Direction;
+
+        FPVector3 forward = filter.Transform->Forward;
+        FPVector3 right = filter.Transform->Right;
+        FP forwardSpeed = FPVector3.Dot(forward, sphereData.Body->Velocity);
+
+        // now rotate
+        FP lateralForce = config.LateralForce.Evaluate(forwardSpeed / config.MaxSpeed);
+
+        if (direction.X != 0)
+        {
+          FP rotationFactor = lateralForce * config.RotationMultiplier * direction.X;
+          filter.Transform->Rotate(FP._0, rotationFactor * frame.DeltaTime, FP._0);
+        }
+
+        FPVector3 force = default;
+        if (direction.Y > 0)
+        {
+          force += direction.Y * forward * config.Acceleration;
+        }
+        FP slipSpeed = FPVector3.Dot(right, sphereData.Body->Velocity);
+        force += right * slipSpeed * config.LateralForceMultiplier;
+        // swizzle from 2D to 3D
+        sphereData.Body->AddForce(force);
+        
+        // snap to sphere position
+        filter.Transform->Position = sphereData.Transform->Position;
+        filter.Transform->Rotation = filter.Transform->Rotation.Normalized;
+      }
+    }
+  }
+}

data/TraktorConfig.cs

@@ -0,0 +1,15 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  partial class TraktorConfig : AssetObject
+  {
+    public FP Acceleration;
+    public FP Drag;
+    public FP MaxSpeed;
+    public FPAnimationCurve LateralForce;
+    public FP LateralForceMultiplier = 1;
+    public FP RotationMultiplier = 1;
+  }
+}

data/TraktorInputSystem.cs

@@ -0,0 +1,33 @@
+using System;
+using Photon.Deterministic;
+using Quantum.Task;
+
+namespace Quantum
+{
+	public unsafe class TraktorInputSystem : SystemThreadedFilter<TraktorInputSystem.Filter>, ISignalOnComponentAdded<Traktor>
+	{
+		public struct Filter
+		{
+			public EntityRef Entity;
+			public Transform3D* Transform;
+			public Traktor* Traktor;
+		}
+
+		public void OnAdded(Frame frame, EntityRef entity, Traktor* traktor)
+		{
+			EntityRef sphere = frame.Create(traktor->SpherePrototype);
+			traktor->Sphere = sphere;
+
+		}
+
+		public override void Update(FrameThreadSafe frame, ref Filter filter)
+		{
+			Input input = default;
+			if (frame.TryGetPointer<Controller>(filter.Entity, out var controller))
+			{
+				input = *((Frame)frame).GetPlayerInput(controller->Player);
+			}
+			filter.Traktor->Update(frame, ref filter, input);
+		}
+	}
+}

data/TraktorView.cs

@@ -0,0 +1,50 @@
+using Quantum;
+using UnityEngine;
+using Photon.Deterministic;
+
+public class TraktorView : MonoBehaviour
+{
+  Vector3 _lastPosition;
+  public float SpeedThreshold = 0.1f;
+  public float RaycastDistance = 0.51f;
+  public float RotationFactor = 8f;
+  public Transform TraktorBody;
+  Quaternion _desiredRotation;
+  private bool _wasGrounded;
+  private EntityView _view;
+  private EntityRef _sphere;
+  void Start()
+  {
+    _view = GetComponent<EntityView>();
+    var frame = QuantumRunner.Default.Game.Frames.Verified;
+    var controller = frame.Get<Controller>(_view.EntityRef);
+    if (QuantumRunner.Default.Session.IsLocalPlayer(controller.Player))
+    {
+      Camera.main.GetComponent<CameraFollow>().Target = transform;
+    }
+
+    if (frame.TryGet<Traktor>(_view.EntityRef, out var traktor))
+    {
+      _sphere = traktor.Sphere;
+    }
+    _lastPosition = transform.position;
+    _desiredRotation = transform.rotation;
+  }
+
+  private void LateUpdate()
+  {
+    var frame = QuantumRunner.Default.Game.Frames.Predicted;
+    if (frame.TryGet<Drivable>(_sphere, out var drivable) && drivable.Grounded && frame.TryGet<PhysicsBody3D>(_sphere, out var body))
+    {
+      var direction = body.Velocity.ToUnityVector3();
+      _desiredRotation = Quaternion.LookRotation(direction.normalized, drivable.SurfaceNormal.ToUnityVector3());
+      var euler = _desiredRotation.eulerAngles;
+      euler.y = 0;
+      _desiredRotation = Quaternion.Euler(euler);
+    }
+    TraktorBody.localRotation = Quaternion.Slerp(TraktorBody.localRotation, _desiredRotation, RotationFactor * Time.deltaTime);
+    _lastPosition = transform.position;
+  }
+
+
+}

data/TurnConfig.cs

@@ -0,0 +1,12 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  public partial class TurnConfig
+  {
+    public Boolean UsesTimer;
+    public Int32 TurnDurationInTicks;
+    public Boolean IsSkippable;
+  }
+}

data/TurnData.cs

@@ -0,0 +1,115 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  partial struct TurnData
+  {
+    public void Update(Frame f)
+    {
+      var config = f.FindAsset<TurnConfig>(ConfigRef.Id);
+      if (config == null || !config.UsesTimer || Status != TurnStatus.Active)
+      {
+        return;
+      }
+      Ticks++;
+      if (Ticks >= config.TurnDurationInTicks)
+      {
+        f.Signals.OnTurnEnded(this, TurnEndReason.Time);
+      }
+    }
+
+    public void AccumulateStats(TurnData from)
+    {
+      Ticks += from.Ticks;
+      Number++;
+    }
+
+    public void SetType(TurnType newType, Frame f = null)
+    {
+      if (Type == newType)
+      {
+        return;
+      }
+      var previousType = Type;
+      Type = newType;
+      f?.Events.TurnTypeChanged(this, previousType);
+    }
+
+    public void SetStatus(TurnStatus newStatus, Frame f = null)
+    {
+      if (Status == newStatus)
+      {
+        return;
+      }
+      var previousStatus = Status;
+      Status = newStatus;
+      f?.Events.TurnStatusChanged(this, previousStatus);
+      if (Status == TurnStatus.Active)
+      {
+        f?.Events.TurnActivated(this);
+      }
+    }
+
+    // frame is only necessary if caller wants to raise events
+    public void ResetTicks(Frame f = null)
+    {
+      ResetData(Type, Status, Entity, Player, ConfigRef, f);
+    }
+
+    public void Reset(TurnConfig config, TurnType type, TurnStatus status, Frame f = null)
+    {
+      ResetData(type, status, Entity, Player, config, f);
+    }
+
+    public void Reset(EntityRef entity, PlayerRef owner, Frame f = null)
+    {
+      ResetData(Type, Status, entity, owner, ConfigRef, f);
+    }
+
+    public void Reset(TurnConfig config, TurnType type, TurnStatus status, EntityRef entity, PlayerRef owner, Frame f = null)
+    {
+      ResetData(type, status, entity, owner, config, f);
+    }
+
+    private void ResetData(TurnType type, TurnStatus status, EntityRef entity, PlayerRef owner, AssetRefTurnConfig config, Frame f = null)
+    {
+      if (entity != EntityRef.None)
+      {
+        Entity = entity;
+      }
+      if (owner != PlayerRef.None)
+      {
+        Player = owner;
+      }
+
+      if (config != null)
+      {
+        ConfigRef = config;
+      }
+
+      var previousType = Type;
+      Type = type;
+      var previousStatus = Status;
+      Status = status;
+
+      Ticks = 0;
+
+      if (Type != previousType)
+      {
+        f?.Events.TurnTypeChanged(this, previousType);
+      }
+
+      if (Status != previousStatus)
+      {
+        f?.Events.TurnStatusChanged(this, previousStatus);
+        if (Status == TurnStatus.Active)
+        {
+          f?.Events.TurnActivated(this);
+        }
+      }
+
+      f?.Events.TurnTimerReset(this);
+    }
+  }
+}

data/TurnData.qtn

@@ -0,0 +1,40 @@
+import PlayCommandData;
+import SkipCommandData;
+
+asset TurnConfig;
+
+enum TurnType { Play, Countdown }
+enum TurnStatus { Inactive, Active, Resolving }
+enum TurnEndReason { Time, Skip, Play, Resolved }
+
+struct TurnData
+{
+    player_ref Player;
+    entity_ref Entity;
+    asset_ref<TurnConfig> ConfigRef;
+    TurnType Type;
+    TurnStatus Status;
+    Int32 Number;
+    Int32 Ticks;
+}
+
+global {
+    TurnData CurrentTurn;
+}
+
+// ------------------ Signals ------------------
+signal OnTurnEnded           (TurnData data, TurnEndReason reason);
+signal OnPlayCommandReceived (PlayerRef player, PlayCommandData data);
+signal OnSkipCommandReceived (PlayerRef player, SkipCommandData data);
+
+// ------------------ Events ------------------
+abstract event TurnEvent                   { TurnData      Turn; }
+synced event TurnTypeChanged   : TurnEvent { TurnType      PreviousType; }
+synced event TurnStatusChanged : TurnEvent { TurnStatus    PreviousStatus; }
+synced event TurnEnded         : TurnEvent { TurnEndReason Reason; }
+synced event TurnTimerReset    : TurnEvent { }
+synced event TurnActivated     : TurnEvent { }
+
+abstract event CommandEvent              { player_ref Player; }
+event PlayCommandReceived : CommandEvent { PlayCommandData Data; }
+event SkipCommandReceived : CommandEvent { SkipCommandData Data; }

data/TurnData.txt

@@ -0,0 +1,115 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  partial struct TurnData
+  {
+    public void Update(Frame f)
+    {
+      var config = f.FindAsset<TurnConfig>(ConfigRef.Id);
+      if (config == null || !config.UsesTimer || Status != TurnStatus.Active)
+      {
+        return;
+      }
+      Ticks++;
+      if (Ticks >= config.TurnDurationInTicks)
+      {
+        f.Signals.OnTurnEnded(this, TurnEndReason.Time);
+      }
+    }
+
+    public void AccumulateStats(TurnData from)
+    {
+      Ticks += from.Ticks;
+      Number++;
+    }
+
+    public void SetType(TurnType newType, Frame f = null)
+    {
+      if (Type == newType)
+      {
+        return;
+      }
+      var previousType = Type;
+      Type = newType;
+      f?.Events.TurnTypeChanged(this, previousType);
+    }
+
+    public void SetStatus(TurnStatus newStatus, Frame f = null)
+    {
+      if (Status == newStatus)
+      {
+        return;
+      }
+      var previousStatus = Status;
+      Status = newStatus;
+      f?.Events.TurnStatusChanged(this, previousStatus);
+      if (Status == TurnStatus.Active)
+      {
+        f?.Events.TurnActivated(this);
+      }
+    }
+
+    // frame is only necessary if caller wants to raise events
+    public void ResetTicks(Frame f = null)
+    {
+      ResetData(Type, Status, Entity, Player, ConfigRef, f);
+    }
+
+    public void Reset(TurnConfig config, TurnType type, TurnStatus status, Frame f = null)
+    {
+      ResetData(type, status, Entity, Player, config, f);
+    }
+
+    public void Reset(EntityRef entity, PlayerRef owner, Frame f = null)
+    {
+      ResetData(Type, Status, entity, owner, ConfigRef, f);
+    }
+
+    public void Reset(TurnConfig config, TurnType type, TurnStatus status, EntityRef entity, PlayerRef owner, Frame f = null)
+    {
+      ResetData(type, status, entity, owner, config, f);
+    }
+
+    private void ResetData(TurnType type, TurnStatus status, EntityRef entity, PlayerRef owner, AssetRefTurnConfig config, Frame f = null)
+    {
+      if (entity != EntityRef.None)
+      {
+        Entity = entity;
+      }
+      if (owner != PlayerRef.None)
+      {
+        Player = owner;
+      }
+
+      if (config != null)
+      {
+        ConfigRef = config;
+      }
+
+      var previousType = Type;
+      Type = type;
+      var previousStatus = Status;
+      Status = status;
+
+      Ticks = 0;
+
+      if (Type != previousType)
+      {
+        f?.Events.TurnTypeChanged(this, previousType);
+      }
+
+      if (Status != previousStatus)
+      {
+        f?.Events.TurnStatusChanged(this, previousStatus);
+        if (Status == TurnStatus.Active)
+        {
+          f?.Events.TurnActivated(this);
+        }
+      }
+
+      f?.Events.TurnTimerReset(this);
+    }
+  }
+}

data/TurnTimerSystem.cs

@@ -0,0 +1,12 @@
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  public unsafe class TurnTimerSystem : SystemMainThread
+  {
+    public override void Update(Frame f)
+    {
+      f.Global->CurrentTurn.Update(f);
+    }
+  }
+}

data/UT.qtn

@@ -0,0 +1,30 @@
+asset UTRoot;
+asset Consideration;
+
+component UTAgent
+{
+	UtilityReasoner UtilityReasoner;
+	AssetRefAIConfig Config;
+}
+
+struct UtilityReasoner
+{
+	AssetRefUTRoot UTRoot;
+	[HideInInspector] list<AssetRefConsideration> Considerations;
+	[HideInInspector] list<UTMomentumPack> MomentumList;
+	[HideInInspector] FP TimeToTick;
+	[HideInInspector] dictionary<AssetRefConsideration, FP> CooldownsDict;
+	[HideInInspector] list<AssetRefConsideration> PreviousExecution;
+}
+
+struct UTMomentumPack
+{
+	AssetRefConsideration ConsiderationRef;
+	UTMomentumData MomentumData;
+}
+
+struct UTMomentumData
+{
+	Int32 Value;
+	Byte DecayAmount;
+}

data/UTAgent.User.cs

@@ -0,0 +1,13 @@
+namespace Quantum
+{
+	public partial struct UTAgent
+	{
+		// Used to setup info on the Unity debugger
+		public string GetRootAssetName(Frame frame) => frame.FindAsset<UTRoot>(UtilityReasoner.UTRoot.Id).Path;
+
+		public AIConfig GetConfig(Frame frame)
+		{
+			return frame.FindAsset<AIConfig>(Config.Id);
+		}
+	}
+}

data/UTManager.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace Quantum
+{
+	public unsafe static class UTManager
+	{
+		public static Action<EntityRef, string> SetupDebugger;
+
+		public static Action<EntityRef, long> ConsiderationChosen;
+		public static Action<EntityRef> OnUpdate;
+
+		/// <summary>
+		/// Initializes the Utility Reasoner, allocating all frame data needed.
+		/// If no UTRoot asset is passed by parameter, it will try to initialize with one already set on the Component, if any.
+		/// </summary>
+		public static void Init(Frame frame, UtilityReasoner* reasoner, AssetRefUTRoot utRootRef = default, EntityRef entity = default)
+		{
+			reasoner->Initialize(frame, utRootRef, entity);
+		}
+
+		public static void Free(Frame frame, UtilityReasoner* reasoner)
+		{
+			reasoner->Free(frame);
+		}
+
+		/// <summary>
+		/// Ticks the UtilityReasoner. The Considerations will be evaluated and the most useful will be executed.
+		/// It can be agnostic to entities, meaning that it is possible to have a UtilityReasoner as part of Global
+		/// </summary>
+		/// <param name="frame"></param>
+		/// <param name="reasoner"></param>
+		/// <param name="entity"></param>
+		public static void Update(Frame frame, UtilityReasoner* reasoner, EntityRef entity = default)
+		{
+			if (entity != default)
+			{
+				OnUpdate?.Invoke(entity);
+			}
+
+			if (reasoner == default && entity != default)
+			{
+				reasoner = &frame.Unsafe.GetPointer<UTAgent>(entity)->UtilityReasoner;
+			}
+
+			reasoner->Update(frame, reasoner, entity);
+		}
+	}
+}

data/UTMomentumData.User.cs

@@ -0,0 +1,7 @@
+namespace Quantum
+{
+	[System.Serializable]
+	public partial struct UTMomentumData
+	{
+	}
+}

data/UTRoot.cs

@@ -0,0 +1,7 @@
+namespace Quantum
+{
+	public partial class UTRoot
+	{
+		public AssetRefConsideration[] ConsiderationsRefs;
+	}
+}

data/UseCardCommand.cs

@@ -0,0 +1,16 @@
+namespace Quantum
+{
+	using Photon.Deterministic;
+
+	public class UseCardCommand : DeterministicCommand
+	{
+		public byte      CardIndex;
+		public FPVector2 Position;
+
+		public override void Serialize(BitStream stream)
+		{
+			stream.Serialize(ref CardIndex);
+			stream.Serialize(ref Position);
+		}
+	}
+}

data/UtilityReasoner.User.cs

@@ -0,0 +1,352 @@
+using Photon.Deterministic;
+using Quantum.Collections;
+
+namespace Quantum
+{
+	public unsafe partial struct UtilityReasoner
+	{
+		public void Initialize(Frame frame, AssetRefUTRoot utRootRef = default, EntityRef entity = default)
+		{
+			// If we don't receive the UTRoot as parameter, we try to find it on the component itself
+			// Useful for pre-seting the UTRoot on a Prototype
+			UTRoot utRootInstance;
+			if (utRootRef == default)
+			{
+				utRootInstance = frame.FindAsset<UTRoot>(UTRoot.Id);
+			}
+			else
+			{
+				UTRoot = utRootRef;
+				utRootInstance = frame.FindAsset<UTRoot>(utRootRef.Id);
+			}
+
+			// Initialize the Reasoner's considerations.
+			// Can be useful further when creating dynamically added Considerations to the Agent (runtime)
+			QList<AssetRefConsideration> considerationsList = frame.AllocateList<AssetRefConsideration>();
+			for (int i = 0; i < utRootInstance.ConsiderationsRefs.Length; i++)
+			{
+				considerationsList.Add(utRootInstance.ConsiderationsRefs[i]);
+			}
+			Considerations = considerationsList;
+
+			CooldownsDict = frame.AllocateDictionary<AssetRefConsideration, FP>();
+
+			QList<AssetRefConsideration> previousExecution = frame.AllocateList<AssetRefConsideration>();
+			for (int i = 0; i < 6; i++)
+			{
+				previousExecution.Add(default);
+			}
+			PreviousExecution = previousExecution;
+
+			MomentumList = frame.AllocateList<UTMomentumPack>();
+
+			if (entity != default)
+			{
+				UTManager.SetupDebugger?.Invoke(entity, utRootInstance.Path);
+			}
+		}
+
+		public void Free(Frame frame)
+		{
+			UTRoot = default;
+			frame.FreeList<AssetRefConsideration>(Considerations);
+			frame.FreeDictionary<AssetRefConsideration, FP>(CooldownsDict);
+			frame.FreeList<AssetRefConsideration>(PreviousExecution);
+			frame.FreeList<UTMomentumPack>(MomentumList);
+		}
+
+		public void Update(Frame frame, UtilityReasoner* reasoner, EntityRef entity = default)
+		{
+			Consideration[] considerations = SolveConsiderationsList(frame, Considerations, reasoner, entity);
+			Consideration chosenConsideration = SelectBestConsideration(frame, considerations, 1, reasoner, entity);
+
+			if (chosenConsideration != default)
+			{
+				chosenConsideration.OnUpdate(frame, reasoner, entity);
+				UTManager.ConsiderationChosen?.Invoke(entity, chosenConsideration.Identifier.Guid.Value);
+			}
+
+			TickMomentum(frame, entity);
+		}
+
+		public Consideration[] SolveConsiderationsList(Frame frame, QListPtr<AssetRefConsideration> considerationsRefs, UtilityReasoner* reasoner, EntityRef entity = default)
+		{
+			QList<AssetRefConsideration> solvedRefs = frame.ResolveList(considerationsRefs);
+			Consideration[] considerationsArray = new Consideration[solvedRefs.Count];
+			for (int i = 0; i < solvedRefs.Count; i++)
+			{
+				considerationsArray[i] = frame.FindAsset<Consideration>(solvedRefs[i].Id);
+			}
+
+			return considerationsArray;
+		}
+
+		public Consideration SelectBestConsideration(Frame frame, Consideration[] considerations, byte depth, UtilityReasoner* reasoner, EntityRef entity = default)
+		{
+			if (considerations == default)
+				return null;
+
+			QList<UTMomentumPack> momentumList = frame.ResolveList(MomentumList);
+
+			// We get the Rank of every Consideration Set
+			// This "filters" the Considerations with higher absolute utility
+			AssetRefConsideration[] highRankConsiderations = new AssetRefConsideration[considerations.Length];
+			int highestRank = -1;
+			int counter = 0;
+			QDictionary<AssetRefConsideration, FP> cooldowns = frame.ResolveDictionary(CooldownsDict);
+
+			for (int i = 0; i < considerations.Length; i++)
+			{
+				Consideration consideration = considerations[i];
+
+				// Force low Rank for Considerations in Cooldown
+				if (cooldowns.Count > 0 && cooldowns.ContainsKey(considerations[i]) == true)
+				{
+					cooldowns[considerations[i]] -= frame.DeltaTime;
+					if (cooldowns[considerations[i]] <= 0)
+					{
+						cooldowns.Remove(considerations[i]);
+					}
+					{
+						continue;
+					}
+				}
+
+				// If the Consideration has Momentum, then it's Rank should is defined by it
+				// Otherwise, we calculate the Rank dynamically
+				int rank;
+				if (ContainsMomentum(momentumList, consideration, out var momentum) == true)
+				{
+					rank = momentum.Value;
+				}
+				else
+				{
+					rank = consideration.GetRank(frame, entity);
+				}
+
+				if (rank > highestRank)
+				{
+					counter = 0;
+
+					highestRank = rank;
+					highRankConsiderations[counter] = considerations[i];
+				}
+				else if (highestRank == rank)
+				{
+					counter++;
+					highRankConsiderations[counter] = considerations[i];
+				}
+			}
+
+			// We clean the indices on the high rank sets that were not selected
+			for (int i = counter + 1; i < highRankConsiderations.Length; i++)
+			{
+				if (highRankConsiderations[i] == default)
+					break;
+
+				highRankConsiderations[i] = default;
+			}
+
+			// Based on the higher rank, we check which Considerations sets have greater utility
+			// Then we choose that set this frame
+			Consideration chosenConsideration = default;
+			FP highestScore = FP.UseableMin;
+			for (int i = 0; i <= counter; i++)
+			{
+				if (highRankConsiderations[i] == default)
+					continue;
+
+				Consideration consideration = frame.FindAsset<Consideration>(highRankConsiderations[i].Id);
+
+				FP score = consideration.Score(frame, entity);
+				if (highestScore < score)
+				{
+					highestScore = score;
+					chosenConsideration = consideration;
+				}
+			}
+
+			if (chosenConsideration != default)
+			{
+				// If the chosen Consideration and it is not already under Momentum,
+				// we add add it there, replacing the previous Momentum (if any)
+				if (chosenConsideration.MomentumData.Value > 0 && ContainsMomentum(momentumList, chosenConsideration, out var momentum) == false)
+				{
+					InsertMomentum(frame, momentumList, chosenConsideration);
+				}
+
+				// If the chosen Consideration has cooldown and it is not yet on the cooldowns dictionary,
+				// we add it there
+				if (chosenConsideration.Cooldown > 0 && cooldowns.ContainsKey(chosenConsideration) == false)
+				{
+					cooldowns.Add(chosenConsideration, chosenConsideration.Cooldown);
+				}
+
+				// Add the chosen set to the choices history
+				OnConsiderationChosen(frame, reasoner, chosenConsideration, entity);
+			}
+			else
+			{
+				OnNoConsiderationChosen(frame, reasoner, depth, entity);
+			}
+
+			// We return the chosen set so it can be executed
+			return chosenConsideration;
+		}
+
+		#region Momentum
+		private bool ContainsMomentum(QList<UTMomentumPack> momentumList, Consideration consideration, out UTMomentumData momentum)
+		{
+			for (int i = 0; i < momentumList.Count; i++)
+			{
+				if (momentumList[i].ConsiderationRef == consideration)
+				{
+					momentum = momentumList[i].MomentumData;
+					return true;
+				}
+			}
+
+			momentum = default;
+			return false;
+		}
+
+		private void InsertMomentum(Frame frame, QList<UTMomentumPack> momentumList, AssetRefConsideration considerationRef)
+		{
+			Consideration newConsideration = frame.FindAsset<Consideration>(considerationRef.Id);
+
+			// First, we check if this should be a replacement, which happens if:
+			// . The momentum list already have that same Depth added
+			// . Or when it have a higher Depth added
+			bool wasReplacedment = false;
+			for (int i = 0; i < momentumList.Count; i++)
+			{
+				Consideration currentConsideration = frame.FindAsset<Consideration>(momentumList[i].ConsiderationRef.Id);
+				if (currentConsideration.Depth == newConsideration.Depth || currentConsideration.Depth > newConsideration.Depth)
+				{
+					momentumList.GetPointer(i)->ConsiderationRef = considerationRef;
+					momentumList.GetPointer(i)->MomentumData = frame.FindAsset<Consideration>(considerationRef.Id).MomentumData;
+
+					// We clear the rightmost momentum entries
+					if (i < momentumList.Count - 1)
+					{
+						for (int k = i + 1; k < momentumList.Count; k++)
+						{
+							momentumList.RemoveAt(k);
+						}
+					}
+
+					wasReplacedment = true;
+					break;
+				}
+			}
+
+			// If there was no replacement, we simply add it to the end of the list as this
+			// consideration probably has higher Depth than the others currently on the list
+			// which can also mean that the list was empty
+			if (wasReplacedment == false)
+			{
+				UTMomentumPack newMomentum = new UTMomentumPack()
+				{
+					ConsiderationRef = considerationRef,
+					MomentumData = frame.FindAsset<Consideration>(considerationRef.Id).MomentumData,
+				};
+				momentumList.Add(newMomentum);
+			}
+		}
+
+		private void TickMomentum(Frame frame, EntityRef entity = default)
+		{
+			QList<UTMomentumPack> momentumList = frame.ResolveList(MomentumList);
+
+			// We decrease the timer and check if it is time already to decay all of the current Momentums
+			TimeToTick -= frame.DeltaTime;
+			bool decay = false;
+			if (TimeToTick <= 0)
+			{
+				decay = true;
+				TimeToTick = 1;
+			}
+
+			for (int i = 0; i < momentumList.Count; i++)
+			{
+				UTMomentumPack* momentum = momentumList.GetPointer(i);
+
+				// If we currently have a commitment, we check if it is done already
+				// If it is done, that Consideration's Rank shall be re-calculated
+				// If it is not done, then the Consideration's Rank will be kept due to the commitment
+				// unless some other Consideration has greater Rank and replaces the current commitment
+				Consideration momentumConsideration = frame.FindAsset<Consideration>(momentum->ConsiderationRef.Id);
+
+				if (momentum->MomentumData.Value > 0 && momentumConsideration.MomentumData.DecayAmount > 0)
+				{
+					if (decay)
+					{
+						momentum->MomentumData.Value -= momentumConsideration.MomentumData.DecayAmount;
+					}
+				}
+
+
+				bool isDone = false;
+				if (momentumConsideration.Commitment != default)
+				{
+					isDone = momentumConsideration.Commitment.Execute(frame, entity);
+				}
+				if (isDone == true || momentum->MomentumData.Value <= 0)
+				{
+					momentum->MomentumData.Value = 0;
+					momentumList.RemoveAt(i);
+				}
+			}
+		}
+		#endregion
+
+		#region ConsiderationsChoiceReactions
+		private static void OnConsiderationChosen(Frame frame, UtilityReasoner* reasoner, AssetRefConsideration chosenConsiderationRef, EntityRef entity = default)
+		{
+			Consideration chosenConsideration = frame.FindAsset<Consideration>(chosenConsiderationRef.Id);
+
+			QList<AssetRefConsideration> previousExecution = frame.ResolveList(reasoner->PreviousExecution);
+
+			if (previousExecution[chosenConsideration.Depth - 1] != chosenConsideration)
+			{
+				// Exit the one that we're replacing
+				var replacedSet = frame.FindAsset<Consideration>(previousExecution[chosenConsideration.Depth - 1].Id);
+				if (replacedSet != default)
+				{
+					replacedSet.OnExit(frame, reasoner, entity);
+				}
+
+				// Exit the consecutive ones
+				for (int i = chosenConsideration.Depth; i < previousExecution.Count; i++)
+				{
+					var cs = frame.FindAsset<Consideration>(previousExecution[i].Id);
+					if (cs == default)
+						break;
+
+					cs.OnExit(frame, reasoner, entity);
+					previousExecution[i] = default;
+				}
+
+				// Insert and Enter on the new chosen consideration
+				previousExecution[chosenConsideration.Depth - 1] = chosenConsideration;
+				chosenConsideration.OnEnter(frame, reasoner, entity);
+			}
+		}
+
+		private static void OnNoConsiderationChosen(Frame frame, UtilityReasoner* reasoner, byte depth, EntityRef entity = default)
+		{
+			QList<AssetRefConsideration> previousExecution = frame.ResolveList(reasoner->PreviousExecution);
+
+			for (int i = depth - 1; i < previousExecution.Count; i++)
+			{
+				var cs = frame.FindAsset<Consideration>(previousExecution[i].Id);
+				if (cs == default)
+					break;
+
+				cs.OnExit(frame, reasoner, entity);
+				previousExecution[i] = default;
+			}
+		}
+		#endregion
+	}
+}

data/WaitLeaf.cs

@@ -0,0 +1,60 @@
+using Photon.Deterministic;
+using System;
+
+namespace Quantum
+{
+	[Serializable]
+	public unsafe partial class WaitLeaf : BTLeaf
+	{
+		// How many time shall be waited
+		// This is measured in seconds
+		public FP Duration;
+
+		// Indexer for us to store the End Time value on the BTAgent itself
+		public BTDataIndex EndTimeIndex;
+
+		public override void Init(Frame frame, AIBlackboardComponent* blackboard, BTAgent* agent)
+		{
+			base.Init(frame, blackboard, agent);
+
+			// We allocate space for the End Time on the Agent so we can change it in runtime
+			agent->AddFPData(frame, 0);
+		}
+
+		public override void OnEnter(BTParams btParams)
+		{
+			base.OnEnter(btParams);
+
+			FP currentTime;
+			FP endTime;
+
+			// Get the current time
+			currentTime = btParams.Frame.BotSDKGameTime;
+			// Add the Duration value so we know when the Leaf will stop running
+			endTime = currentTime + Duration;
+
+			// Store the final value on the Agent data
+			btParams.Agent->SetFPData(btParams.Frame, endTime, EndTimeIndex.Index);
+		}
+
+		protected override BTStatus OnUpdate(BTParams btParams)
+		{
+			FP currentTime;
+			FP endTime;
+
+			currentTime = btParams.Frame.BotSDKGameTime;
+			endTime = btParams.Agent->GetFPData(btParams.Frame, EndTimeIndex.Index);
+
+			// If waiting time isn't over yet, then we need more frames executing this Leaf
+			// So we say that we're still Running
+			if (currentTime < endTime)
+			{
+				return BTStatus.Running;
+			}
+
+			// If the waiting time is over, then we succeeded on waiting that amount of time
+			// Then we return Success
+			return BTStatus.Success;
+		}
+	}
+}

data/input.txt

@@ -0,0 +1,120 @@
+Introduction
+Input is a crucial component of Quantum's core architecture. In a deterministic networking library, the output of the system is fixed and predetermined given a certain input. This means that as long as the input is the same across all clients in the network, the output will also be the same.
+
+Back To Top
+ 
+
+Defining In DSL
+Input can be defined in any dsl file. For example, an input struct where you have a movement direction and a singluar jump button would look something like this:
+
+input
+{
+    button Jump;
+    FPVector3 Direction;
+}
+The server is responsible for batching and sending down input confirmations for full tick-sets (all player's input). For this reason, this struct should be kept to a minimal size as much as possible.
+
+Back To Top
+ 
+
+Commands
+deterministic commands are another input path for Quantum, and can have arbitrary data and size, which make them ideal for special types of inputs, like "buy this item", "teleport somewhere", etc.
+
+Back To Top
+ 
+
+Polling In Unity
+To send input to the Quantum simulation, you must poll for it inside of unity. To do this, we subscribe to the PollInput callback inside of a MonoBehaviour in our gameplay scene.
+
+private void OnEnable()
+{
+  QuantumCallback.Subscribe(this, (CallbackPollInput callback) => PollInput(callback));
+}
+Then, in the callback, we read from out input source and populate our struct.
+
+public void PollInput(CallbackPollInput callback)
+ {
+  Quantum.Input i = new Quantum.Input();
+
+  var direction = new Vector3();
+  direction.x = UnityEngine.Input.GetAxisRaw("Horizontal");
+  direction.y = UnityEngine.Input.GetAxisRaw("Vertical");
+
+  i.Jump = UnityEngine.Input.GetKeyDown(KeyCode.Space);
+
+  // convert to fixed point.
+  i.Direction = direction.ToFPVector3();
+
+  callback.SetInput(i, DeterministicInputFlags.Repeatable);
+}
+NOTE: The float to fixed point conversion here is deterministic because it is done before it is shared with the simulation.
+
+Back To Top
+ 
+
+Optimization
+It is genrally best practice to make sure that your Input definition consumes as little bandwidth as possible in order to maximize the amount of players your game can handle. Below are a few ways to optimize it.
+
+Back To Top
+ 
+
+Buttons
+Instead of using booleans or similar data types to represent key presses, the Button type is used inside the Input DSL definition. This is because it only uses one bit per instance, so it is favorable to use where possible. Although they only use one bit over the network, locally they will contain a bit more game state. This is because the single bit is only representative of whether or not the button was pressed during the current frame, the rest of the information is computed locally. Buttons are defined as follows:
+
+input
+{
+    button Jump;
+}
+Back To Top
+ 
+
+Encoded Direction
+In a typical setting, movement is often represented using a direction vector, often defined in a DSL file as such:
+
+input
+{
+    FPVector2 Direction;
+}
+However, FPVector2 is comprised of two 'FP', which takes up 16 bytes of data, which can be a lot of data sent, especially with many clients in the same room. One such way of optimizing it, is by extending the Input struct and encoding the directional vector into a Byte instead of sending the full vector every single time. One such implemetation is as follows:
+
+First, we define our input like normal, but instead of including an FPVector2 for direction, we replace it with a Byte where we will store the encoded version.
+
+input
+{
+    Byte EncodedDirection;
+}
+Next, we extend the input struct the same way a component is extended (see: adding functionality):
+
+namespace Quantum
+{
+    partial struct Input
+    {
+        public FPVector2 Direction
+        {
+            get
+            {
+                if (EncodedDirection == default)
+                    return default;
+
+                Int32 angle = ((Int32)EncodedDirection - 1) * 2;
+
+                return FPVector2.Rotate(FPVector2.Up, angle * FP.Deg2Rad);
+            }
+            set
+            {
+                if (value == default)
+                {
+                    EncodedDirection = default;
+                        return;
+                }
+
+                var angle = FPVector2.RadiansSigned(FPVector2.Up, value) * FP.Rad2Deg;
+
+                angle = (((angle + 360) % 360) / 2) + 1;
+
+                EncodedDirection = (Byte) (angle.AsInt);
+            }
+        }
+    }
+}
+This implementation allows for the same usage as before, but it only takes up a singular byte instead of 16 bytes. It does this by utilzing a Direction property, which encodes and decodes the value from EncodedDirection automatically. No newline at end of file

data/kinematic character.txt

@@ -0,0 +1,397 @@
+Introduction
+A Kinematic Character Controller, KCC for short, is used to move a character within the world according to its own set of rules. Using a KCC rather than physics/force based movement allows for tighter control and snappy movement. Although those concepts are core to every game, they vary tremendously in their definition as they are related to the overall gameplay. Therefore the KCCs included in the Quantum SDK are to be considered a starting point; however, game developers will likely have to create their own in order to get the best possible results for their specific context.
+
+Quantum comes with two pre-build KCCs, one for 2D (side-scrolling) and one for 3D movement. The API allows characters to move through terrains, climb steps, slide down slopes, and use moving platforms.
+
+The KCCs take physics data of both static and dynamic objects into consideration when calculating the movement vectors. Objects will block and define the character's movement. Collision callbacks with the environment objects will be trigged as well.
+
+Back To Top
+ 
+
+Requirements
+To use or add a KCC to an entity, the entity has to already have a Transform component. A PhysicsBody can be used but is not necessary; it is generally advised against using a PhysicsBody with a KCC as the physics system may affect it and result in unintended movement.
+
+If you are not familiar with Quantum's Physics yet, please review the Physics documentation first.
+
+Back To Top
+ 
+
+Raycasts & ShapeOverlap
+The KCC only uses ShapeOverlaps - circle for 2D and sphere for 3D - to calculate its movement. Thus an entity with only a KKC component will be ignored by raycasts. Should the entity be subject to raycasting, it has to also carry a PhysicsCollider.
+
+Back To Top
+ 
+
+Note
+This page covers both the 2D and 3D KCCs.
+
+Back To Top
+ 
+
+The Character Controller Component
+You can add the CharacterController component to your entity by either:
+
+adding the "Character Controller" component to the Entity Prototype in Unity; or,
+adding the "Character Controller" component via code.
+KCC 2D and 2D Components in Unity
+The Character Controller 2D and 3D components attached to an Entity Prototype in the Unity Editor.
+To add the Character Controller via code, follow the examples below.
+
+// 2D KCC
+var kccConfig = FindAsset<CharacterController2DConfig>(KCC_CONFIG_PATH);
+var kcc = new CharacterController2D();
+kcc.Init(f, kccConfig)
+f.Add(entity, kcc);
+
+// 3D KCC
+var kccConfig = FindAsset<CharacterController3DConfig>(KCC_CONFIG_PATH);
+var kcc = new CharacterController3D();
+kcc.Init(f, kccConfig)
+f.Add(entity, kcc);
+Back To Top
+ 
+
+Note
+The component has to be initiliazed after being created. The available initializing options are:
+
+(code) the Init() method without parameter, it will load the DefaultCharacterController from Assets/Resources/DB/Configs.
+(code) the Init() method with parameter, it will load the passed in CharacterControllerConfig.
+(editor) add the CharacterControllerConfig to the Config slot in the Character Controller component.
+Back To Top
+ 
+
+The Character Controller Config
+Create your own KCC config asset via the context menu under Create > Quantum > Assets > Physics > CharacterController2D/3D.
+
+
+Default Config Assets
+The default 2D and 3D KCC Config assets are located inside the Assets/Resources/DB/Configs folder. Here is how the 3D KCC config looks like:
+
+KCC 3D Default Config
+The DefaultCharacterController3D Config Asset.
+Back To Top
+ 
+
+A Brief Explanation Into The Config Fields
+Offset is used to define the KCC local position based into the entity position. It is commonly used to position the center of the KCC at the feet of the character. Remember: the KCC is used to move the character, so it does not necessarily have to encapsulate the character's whole body.
+Radius defines the boundaries of the character and should encompass the character horizontal size. This is used to know whether a character can move in a certain direction, a wall is blocking the movement, a step is to be climbed, or a slope to be slid on.
+Max Penetration smoothens the movement when a character penetrates other physics objects. If the character passes the Max Penetration, a hard fix will be applied and snap it into the correct position. Reducing this value to zero will apply all corrections fully and instantly; this may result in jagged movement.
+Extent defines a radius in which collisions are detected preemptively.
+Max Contacts is used to select the amount of contact points computed by the KCC. 1 will usually work fine and is the most performant option. If you experience jerky movement, try setting this to 2; the additional overhead is negligible.
+Layer Mask defines which collider layers should be taken into consideration by the physics query performed by the KCC.
+Air Control toggle to True and the KCC is able to perform movement adjustments when it not touching the ground.
+Acceleration defines how fast the character accelerates.
+Base Jump Impulse defines the strength of the impulse when calling the KCC Jump() method. If no value is passed to the method, this value will be used.
+Max Speed caps the character's maximal horizontal speed.
+Gravity applies a gravity force to the KCC.
+Max Slope defines the maximal angle, in degrees, the character can walk up and down.
+Max Slope Speed limits the speed at which the character slides down a slope when the movement type is Slope Fall instead of Horizontal Fall.
+Back To Top
+ 
+
+Character Controller API
+The API shown below focuses on the 3D KCC. The 2D and 3D APIs are very similar though.
+
+
+Properties And Fields
+Each CharacterController component has these fields.
+
+public FP MaxSpeed { get; set;}
+public FPVector3 Velocity { get; set;}
+public bool Grounded { get; set;}
+public FP CurrentSpeed { get;}
+public AssetGUID ConfigId { get;}
+Back To Top
+ 
+
+Tip
+The MaxSpeed is a cached value after initialization. It can therefore be modified at runtime, e.g. when performing dashes.
+
+Back To Top
+ 
+
+API
+Each KCC components has the following methods:
+
+// Initialization
+public void Init(FrameBase frame, CharacterController3DConfig config = null);
+
+// Jump
+public void Jump(FrameBase frame, bool ignoreGrounded = false, FP? impulse = null);
+
+// Move
+public void Move(FrameBase frame, EntityRef entity, FPVector3 direction, IKCCCallbacks3D callback = null, int? layerMask = null, Boolean? useManifoldNormal = null, FP? deltaTime = null);
+
+// Raw Information
+public static CharacterController3DMovement ComputeRawMovement(Frame frame, EntityRef entity, Transform3D* transform, CharacterController3D* kcc, FPVector3 direction, IKCCCallbacks3D callback = null, int? layerMask = null, bool? useManifoldNormal = null);
+The Jump and Move methods are convenient for prototyping, while ComputeRawMovement provides the key information for creating your own custom movement. In the example KCC's provided by Quantum, the information from ComputeRawMovement is used by the internal steering method ComputeRawSteer to compute the steering used in Move.
+
+IMPORTANT: The implementations of Jump(), Move() and ComputeRawSteer() are presented below for fostering understanding and help create custom implementations specific to the game's requirements.
+
+Back To Top
+ 
+
+CharacterController3DMovement
+ComputeRawMovement() computes the environmental data necessary for the steering by performing a ShapeOverlap and processing the data. The method returns a CharacterController3DMovement struct which can then be applied to the character movement. The movement data provided can also be used to create a custom steering implementation.
+
+The CharacterController3DMovement struct holds the following information:
+
+public enum CharacterMovementType
+{
+    None, // grounded with no desired direction passed
+    FreeFall, // no contacts within the Radius
+    SlopeFall, // there is at least 1 ground contact within the Radius, specifically a contact with a normal angle vs -gravity <= maxSlopeAngle). It is possible to be "grounded" without this type of contact (see Grounded property in the CharacterController3DMovement)
+    Horizontal, // there is NO ground contact, but there is at least one lateral contact (normal angle vs -gravity > maxSlopeAngle)
+}
+
+public struct CharacterController3DMovement
+{
+  public CharacterMovementType Type;
+
+  // the surface normal of the closest unique contact
+  public FPVector3 NearestNormal;
+
+  // the average normal from all contacts
+  public FPVector3 AvgNormal;
+
+  // the normal of the closest contact that qualifies as ground
+  public FPVector3 GroundNormal;
+
+  // the surface tangent (from GroundNormal and the derived direction) for Horizontal move, or the normalized desired direction when in CharacterMovementType.FreeFall
+  public FPVector3 Tangent;
+
+  // surface tangent computed from closest the contact normal vs -gravity (does not consider current velocity of CC itself).
+  public FPVector3 SlopeTangent;
+
+  // accumulated projected correction from all contacts within the Radius. It compensates with dot-products to NOT overshoot.
+  public FPVector3 Correction;
+
+  // max penetration of the closest contact within the Radius
+  public FP Penetration;
+
+  // uses the EXTENDED radius to assign this Boolean AND the GroundedNormalas to avoid oscilations of the grounded state when moving over slightly irregular terrain
+  public Boolean Grounded;
+
+  // number of contacts within Radius
+  public int Contacts;
+}
+ComputeRawMovement() is used by the Move() method.
+
+Back To Top
+ 
+
+Jump()
+This is only a reference implementation.
+The Jump simply adds an impulse to the KCC's current Velocity and toggles the Jumped boolean which will be processed by the internal ComputeRawSteer Method.
+
+public void Jump(FrameBase frame, bool ignoreGrounded = false, FP? impulse = null) {
+
+  if (Grounded || ignoreGrounded) {
+
+    if (impulse.HasValue)
+      Velocity.Y.RawValue = impulse.Value.RawValue;
+    else {
+      var config = frame.FindAsset(Config);
+      Velocity.Y.RawValue = config.BaseJumpImpulse.RawValue;
+    }
+
+    Jumped = true;
+  }
+}
+Back To Top
+ 
+
+Move()
+This is only a reference implementation.
+Move() takes the following things by taking into consideration when calculating the character's new position:
+
+the current position
+the direction
+the gravity
+jumps
+slopes
+and more
+All these aspects can be defined in the config asset passed to the Init() method. This is convenient for prototyping FPS/TPS/Action games which have terrains, mesh colliders and primitives.
+
+NOTE: Since it calculates everything and returns a final FPVector3 result, it does not give you much control over the movement itself. For tighter control over the movement, you should use ComputeRawMovement() and create your own custom steering + movement.
+
+public void Move(Frame frame, EntityRef entity, FPVector3 direction, IKCCCallbacks3D callback = null, int? layerMask = null, Boolean? useManifoldNormal = null, FP? deltaTime = null) {
+  Assert.Check(frame.Has<Transform3D>(entity));
+
+  var transform = frame.GetPointer<Transform3D>(entity);
+  var dt        = deltaTime ?? frame.DeltaTime;
+
+  CharacterController3DMovement movementPack;
+  fixed (CharacterController3D* thisKcc = &this) {
+    movementPack = ComputeRawMovement(frame, entity, transform, thisKcc, direction, callback, layerMask, useManifoldNormal);
+  }
+
+  ComputeRawSteer(frame, ref movementPack, dt);
+
+  var movement = Velocity * dt;
+  if (movementPack.Penetration > FP.EN3) {
+    var config = frame.FindAsset<CharacterController3DConfig>(Config.Id);
+    if (movementPack.Penetration > config.MaxPenetration) {
+      movement += movementPack.Correction;
+    } else {
+      movement += movementPack.Correction * config.PenetrationCorrection;
+    }
+  }
+
+  transform->Position += movement;
+}
+Back To Top
+ 
+
+ComputeRawSteer()
+Steering involves computing the movement based on the position, radius and velocity of the character, and corrects the movement if necessary.
+
+This is only a reference implementation.
+ComputeRawSteer is an internal method that does the bulk of the movement calculations based on the type of movement the character is currently performing. In the example KCCs, Move requests the movementPack values from ComputeRawMovement and passes them to ComputeRawSteer.
+
+private void ComputeRawSteer(FrameThreadSafe f, ref CharacterController3DMovement movementPack, FP dt) {
+
+  Grounded = movementPack.Grounded;
+  var config = f.FindAsset(Config);
+  var minYSpeed = -FP._100;
+  var maxYSpeed = FP._100;
+
+  switch (movementPack.Type) {
+
+    // FreeFall
+    case CharacterMovementType.FreeFall:
+
+      Velocity.Y -= config._gravityStrength * dt;
+
+      if (!config.AirControl || movementPack.Tangent == default(FPVector3)) {
+        Velocity.X = FPMath.Lerp(Velocity.X, FP._0, dt * config.Braking);
+        Velocity.Z = FPMath.Lerp(Velocity.Z, FP._0, dt * config.Braking);
+      } else {
+        Velocity += movementPack.Tangent * config.Acceleration * dt;
+      }
+
+      break;
+
+    // Grounded movement
+    case CharacterMovementType.Horizontal:
+
+      // apply tangent velocity
+      Velocity += movementPack.Tangent * config.Acceleration * dt;
+      var tangentSpeed = FPVector3.Dot(Velocity, movementPack.Tangent);
+
+      // lerp current velocity to tangent
+      var tangentVel = tangentSpeed * movementPack.Tangent;
+      var lerp = config.Braking * dt;
+      Velocity.X = FPMath.Lerp(Velocity.X, tangentVel.X, lerp);
+      Velocity.Z = FPMath.Lerp(Velocity.Z, tangentVel.Z, lerp);
+
+      // we only lerp the vertical velocity if the character is not jumping in this exact frame,
+      // otherwise it will jump with a lower impulse
+      if (Jumped == false) {
+        Velocity.Y = FPMath.Lerp(Velocity.Y, tangentVel.Y, lerp);
+      }
+
+      // clamp tangent velocity with max speed
+      var tangentSpeedAbs = FPMath.Abs(tangentSpeed);
+      if (tangentSpeedAbs > MaxSpeed) {
+        Velocity -= FPMath.Sign(tangentSpeed) * movementPack.Tangent * (tangentSpeedAbs - MaxSpeed);
+      }
+
+      break;
+
+    // Sliding due to excessively steep slope
+    case CharacterMovementType.SlopeFall:
+
+      Velocity += movementPack.SlopeTangent * config.Acceleration * dt;
+      minYSpeed = -config.MaxSlopeSpeed;
+
+      break;
+
+    // No movement, only deceleration
+    case CharacterMovementType.None:
+
+      var lerpFactor = dt * config.Braking;
+
+      if (Velocity.X.RawValue != 0) {
+        Velocity.X = FPMath.Lerp(Velocity.X, default, lerpFactor);
+        if (FPMath.Abs(Velocity.X) < FP.EN1) {
+          Velocity.X.RawValue = 0;
+        }
+      }
+
+      if (Velocity.Z.RawValue != 0) {
+        Velocity.Z = FPMath.Lerp(Velocity.Z, default, lerpFactor);
+        if (FPMath.Abs(Velocity.Z) < FP.EN1) {
+          Velocity.Z.RawValue = 0;
+        }
+      }
+
+      // we only lerp the vertical velocity back to 0 if the character is not jumping in this exact frame,
+      // otherwise it will jump with a lower impulse
+      if (Velocity.Y.RawValue != 0 && Jumped == false) {
+        Velocity.Y = FPMath.Lerp(Velocity.Y, default, lerpFactor);
+        if (FPMath.Abs(Velocity.Y) < FP.EN1) {
+          Velocity.Y.RawValue = 0;
+        }
+      }
+
+      minYSpeed = 0;
+
+      break;
+  }
+
+  // horizontal is clamped elsewhere
+  if (movementPack.Type != CharacterMovementType.Horizontal) {
+    var h = Velocity.XZ;
+
+    if (h.SqrMagnitude > MaxSpeed * MaxSpeed) {
+      h = h.Normalized * MaxSpeed;
+    }
+
+    Velocity.X = h.X;
+    Velocity.Y = FPMath.Clamp(Velocity.Y, minYSpeed, maxYSpeed);
+    Velocity.Z = h.Y;
+  }
+
+  // reset jump state
+  Jumped = false;
+}
+Back To Top
+ 
+
+Collision Callbacks
+Whenever the KCC detects intersections with colliders a callback is triggered.
+
+public interface IKCCCallbacks2D
+{
+    bool OnCharacterCollision2D(FrameBase f, EntityRef character, Physics2D.Hit hit);
+    void OnCharacterTrigger2D(FrameBase f, EntityRef character, Physics2D.Hit hit);
+}
+
+public interface IKCCCallbacks3D
+{
+    bool OnCharacterCollision3D(FrameBase f, EntityRef character, Physics3D.Hit3D hit);
+    void OnCharacterTrigger3D(FrameBase f, EntityRef character, Physics3D.Hit3D hit);
+}
+To receive the callbacks and use its information implement the corresponding IKCCCallbacks interface in a system.
+
+Important Note that the collision callbacks return a Boolean value. This is allows you decide whether a collision should be ignored. Returning false makes the character pass through physics object it collided with.
+
+Besides implementing the callbacks the movement methods should also pass the IKCCCallbacks object; below is a code snippet using the collision callbacks.
+
+public unsafe class SampleSystem : SystemMainThread, IKCCCallbacks3D
+{
+  public bool OnCharacterCollision3D(FrameBase f, EntityRef character, Physics3D.Hit3D hit) {
+    // read the collision information to decide if this should or not be ignored
+    return true;
+  }
+
+  public void OnCharacterTrigger3D(FrameBase f, EntityRef character, Physics3D.Hit3D hit) {
+  }
+
+  public override void Update(Frame f) {
+    // [...]
+    // adding the IKCCCallbacks3D as the last parameter (this system, in this case)
+    var movement = CharacterController3D.Move((Entity*)character, input->Direction, this);
+    // [...]
+}

data/list1.txt

@@ -0,0 +1,10 @@
+In quantum we can to list as metioned below.
+
+component Targets {
+  list<EntityRef> Enemies;
+}
+The basic API methods for dealing with these Lists are:
+
+Frame.AllocateList<T>()
+Frame.FreeList(QListPtr<T> ptr)
+Frame.ResolveList(QListPtr<T> ptr)