Upload 84 files

data/CameraBehavior.cs

@@ -0,0 +1,25 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Quantum;
+
+public class CameraBehavior : QuantumCallbacks
+{
+  private bool _isInverted = false;
+
+  public override void OnUpdateView(QuantumGame game)
+  {
+    var player = game.Session.LocalPlayerIndices[0];
+    if (player != 0 && !_isInverted)
+    {
+      transform.eulerAngles = new Vector3(transform.eulerAngles.x, transform.eulerAngles.y +180, transform.eulerAngles.z);
+
+      for (int i = 0; i < ChessViewUpdater.Instance.Pieces.Length; i++)
+      {
+        var p = ChessViewUpdater.Instance.Pieces[i];
+        p.transform.eulerAngles = new Vector3(p.transform.eulerAngles.x, p.transform.eulerAngles.y, p.transform.eulerAngles.z + 180);
+      }
+      _isInverted = true;
+    }
+  }
+}

data/CameraFollow.cs

@@ -0,0 +1,161 @@
+using Photon.Deterministic;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+[RequireComponent(typeof(Camera))]
+public class CameraFollow : MonoBehaviour
+{
+  public Transform Target;
+  public Quantum.LayerMask OcclusionQueryMask = -1;
+  [SerializeField, Range(2f, 15f)]
+  float distance = 5f;
+  [SerializeField, Range(0.1f, 5f)]
+  float scrollSpeed = 1f;
+  [SerializeField, Min(0f)]
+  float focusRadius = 1f;
+  [SerializeField, Range(0f, 1f)]
+  float focusCentering = 0.5f;
+
+  [SerializeField, Range(1f, 360f)]
+  float rotationSpeed = 90f;
+  [SerializeField, Range(-30f, 89f)]
+  float minVerticalAngle = -30f, maxVerticalAngle = 60f;
+
+  Vector3 focusPoint;
+  Vector2 orbitAngles = new Vector2(45f, 0f);
+
+  private Camera _camera;
+  void Awake()
+  {
+    //focusPoint = focus.position;
+    transform.localRotation = Quaternion.Euler(orbitAngles);
+    _camera = GetComponent<Camera>();
+  }
+  void LateUpdate()
+  {
+    if (Target == null) return;
+    UpdateDistance();
+    UpdateFocusPoint();
+    Quaternion lookRotation;
+    if (ManualRotation())
+    {
+      ConstrainAngles();
+      lookRotation = Quaternion.Euler(orbitAngles);
+    }
+    else
+    {
+      lookRotation = transform.localRotation;
+    }
+    
+    Vector3 lookDirection = lookRotation * Vector3.forward;
+    Vector3 lookPosition = focusPoint - lookDirection * distance;
+
+    if (Cast(focusPoint, lookRotation, -lookDirection, out var hitDistance, distance - _camera.nearClipPlane))
+    {
+      lookPosition = focusPoint - lookDirection * (hitDistance + _camera.nearClipPlane);
+    }
+
+    transform.SetPositionAndRotation(lookPosition, lookRotation);
+  }
+
+  private unsafe bool Cast(Vector3 origin, Quaternion rotation, Vector3 direction, out float hitDistance, float distance)
+  {
+    hitDistance = 0;
+
+    var frame = QuantumRunner.Default?.Game?.Frames.Verified;
+    if (frame != null)
+    {
+      var shape = Quantum.Shape3D.CreateBox(CameraPlaneExtends.ToFPVector3());
+      var options = Quantum.QueryOptions.ComputeDetailedInfo | Quantum.QueryOptions.HitAll;
+      var hit = frame.Physics3D.ShapeCast(origin.ToFPVector3(), rotation.ToFPQuaternion(), &shape, (direction * distance).ToFPVector3(), OcclusionQueryMask, options);
+      if (hit.HasValue)
+      {
+        hitDistance = (origin - hit.Value.Point.ToUnityVector3()).magnitude;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  Vector3 CameraPlaneExtends
+  {
+    get
+    {
+      Vector3 halfExtends;
+      halfExtends.y =
+        _camera.nearClipPlane *
+        Mathf.Tan(0.5f * Mathf.Deg2Rad * _camera.fieldOfView) * 1.25f;
+      halfExtends.x = halfExtends.y * _camera.aspect;
+      halfExtends.z = 0.01f;
+      return halfExtends;
+    }
+  }
+
+  void UpdateDistance()
+  {
+    distance += Input.GetAxisRaw("Mouse ScrollWheel") * scrollSpeed;
+    distance = Mathf.Clamp(distance, 2, 15);
+  }
+
+  bool ManualRotation()
+  {
+    Vector2 input = new Vector2(
+      -Input.GetAxis("Mouse Y"),
+      Input.GetAxis("Mouse X")
+    );
+    const float e = 0.001f;
+    if (input.x < e || input.x > e || input.y < e || input.y > e)
+    {
+      orbitAngles += rotationSpeed * Time.unscaledDeltaTime * input;
+      return true;
+    }
+    return false;
+  }
+
+  void UpdateFocusPoint()
+  {
+    Vector3 targetPoint = Target.position;
+    if (focusRadius > 0f)
+    {
+      float distance = Vector3.Distance(targetPoint, focusPoint);
+      float t = 1f;
+      if (distance > 0.01f && focusCentering > 0f)
+      {
+        t = Mathf.Pow(1f - focusCentering, Time.unscaledDeltaTime);
+      }
+      if (distance > focusRadius)
+      {
+        t = Mathf.Min(t, focusRadius / distance);
+      }
+      focusPoint = Vector3.Lerp(targetPoint, focusPoint, t);
+    }
+    else
+    {
+      focusPoint = targetPoint;
+    }
+  }
+
+  void ConstrainAngles()
+  {
+    orbitAngles.x =
+      Mathf.Clamp(orbitAngles.x, minVerticalAngle, maxVerticalAngle);
+
+    if (orbitAngles.y < 0f)
+    {
+      orbitAngles.y += 360f;
+    }
+    else if (orbitAngles.y >= 360f)
+    {
+      orbitAngles.y -= 360f;
+    }
+  }
+
+  void OnValidate()
+  {
+    if (maxVerticalAngle < minVerticalAngle)
+    {
+      maxVerticalAngle = minVerticalAngle;
+    }
+  }
+}

data/CardManager.cs

@@ -0,0 +1,176 @@
+namespace Quantum
+{
+	using Photon.Deterministic;
+
+	unsafe partial struct CardManager
+	{
+		// CONSTANTS
+
+		public const byte AVAILABLE_CARDS_COUNT = 4;
+	
+		// PUBLIC METHODS
+
+		public void Initialize(Frame frame, CardInfo[] cards, GameplaySettings settings)
+		{
+			var availableCards = frame.AllocateList<CardInfo>(AVAILABLE_CARDS_COUNT);
+			var cardQueue      = frame.AllocateList<CardInfo>(cards.Length);
+
+			CardQueue      = cardQueue;
+			AvailableCards = availableCards;
+
+			for (int idx = 0, count = cards.Length; idx < count; idx++)
+			{
+				cardQueue.Add(cards[idx]);
+			}
+
+			cardQueue.Shuffle(frame.RNG);
+
+			for (int idx = 0; idx < AVAILABLE_CARDS_COUNT; idx++)
+			{
+				availableCards.Add(cardQueue[idx]);
+			}
+
+			QueueHeadIndex = AVAILABLE_CARDS_COUNT;
+
+			CurrentEnergy = (int)settings.StartEnergy;
+			MaxEnergy     = (int)settings.MaxEnergy;
+		}
+
+		public void SetFillRate(FP energyFillRate)
+		{
+			EnergyFillRate = energyFillRate;
+		}
+
+		public void Deinitialize(Frame frame)
+		{
+			frame.FreeList(AvailableCards);
+			frame.FreeList(CardQueue);
+
+			AvailableCards = default;
+			CardQueue      = default;
+		}
+
+		public void Update(Frame frame, EntityRef entity)
+		{
+			if (CardQueue.Ptr.Offset == 0)
+				return;
+
+			CurrentEnergy  = FPMath.Clamp(CurrentEnergy + frame.DeltaTime * EnergyFillRate, FP._0, MaxEnergy);
+			NextFillTime  -= frame.DeltaTime;
+
+			if (EmptySlots > 0 && NextFillTime <= FP._0)
+			{
+				FillCardSlot(frame, entity);
+			}
+		}
+
+		public void UseCard(Frame frame, EntityRef entity, PlayerRef owner, byte cardIndex, FPVector2 position, FP rotation)
+		{
+			if (cardIndex < 0 || cardIndex >= AVAILABLE_CARDS_COUNT)
+			{
+				Log.Error($"Out of range card use request Index: {cardIndex}");
+				return;
+			}
+
+			var availableCards = frame.ResolveList(AvailableCards);
+			var card           = availableCards[cardIndex];
+
+			if (card.CardSettings.Id.IsValid == false)
+			{
+				Log.Error($"Invalid card use request. Index: {cardIndex}");
+				return;
+			}
+
+			var settings = frame.FindAsset<CardSettings>(card.CardSettings.Id);
+			if (settings.EnergyCost > CurrentEnergy)
+			{
+				Log.Error($"Not enough energy card request. Index: {cardIndex} Cost: {settings.EnergyCost} Current: {CurrentEnergy}");
+				return;
+			}
+
+			if (settings is UnitSettings)
+			{
+				var gameplay = frame.Unsafe.GetPointerSingleton<Gameplay>();
+				if (gameplay->IsValidUnitPosition(frame, owner, position) == false)
+				{
+					Log.Error($"Invalid unit spawn position. Position: {position}");
+					return;
+				}
+			}
+
+			frame.SpawnCard(settings, owner, position, rotation, card.Level);
+
+			AddCardToQueue(frame, card);
+
+			CurrentEnergy -= settings.EnergyCost;
+			availableCards[cardIndex] = default;
+			EmptySlots += 1;
+
+			frame.Events.CardsChanged(entity);
+		}
+
+		// PRIVATE METHODS
+
+		private void FillCardSlot(Frame frame, EntityRef entity)
+		{
+			var availableCards = frame.ResolveList(AvailableCards);
+
+			for (int idx = 0; idx < AVAILABLE_CARDS_COUNT; idx++)
+			{
+				if (availableCards[idx].CardSettings.Id.IsValid == true)
+					continue;
+
+				var cardQueue = frame.ResolveList(CardQueue);
+
+				availableCards[idx] = cardQueue[QueueHeadIndex];
+				QueueHeadIndex      = (byte)((QueueHeadIndex + 1) % cardQueue.Count);
+				EmptySlots         -= 1;
+				NextFillTime        = FP._2;
+
+				frame.Events.CardsChanged(entity);
+				break;
+			}
+		}
+
+		private void AddCardToQueue(Frame frame, CardInfo card)
+		{
+			var cardQueue = frame.ResolveList(CardQueue);
+
+			cardQueue[QueueTailIndex] = card;
+			QueueTailIndex            = (byte)((QueueTailIndex + 1) % cardQueue.Count);
+		}
+
+		private FPVector2 TransformPosition(FPVector2 position, int unitCount, int unitIndex)
+		{
+			if (unitCount == 1)
+				return position;
+
+			if (unitCount <= 4)
+			{
+				var rotationOffset = FP.Rad_180 * FP._2 / unitCount * unitIndex;
+				position += FPVector2.Rotate(FPVector2.Right * FP._0_50, rotationOffset);
+			}
+
+			if (unitCount <= 12)
+			{
+				if (unitIndex < 4)
+				{
+					var rotationOffset = FP.Rad_180 * FP._2 / 4 * unitIndex;
+					position += FPVector2.Rotate(FPVector2.Right * FP._0_50, rotationOffset);
+				}
+				else
+				{
+					var rotationOffset = FP.Rad_180 * FP._2 / (unitCount - 4) * unitIndex;
+					position += FPVector2.Rotate(FPVector2.Right, rotationOffset);
+				}
+			}
+
+			return position;
+		}
+	}
+
+	[System.Serializable]
+	unsafe partial struct CardInfo
+	{
+	}
+}

data/CardManager.qtn

@@ -0,0 +1,36 @@
+asset CardSettings;
+
+[ExcludeFromPrototype]
+component CardManager
+{
+	Byte           EmptySlots;
+	Byte           QueueHeadIndex;
+	Byte           QueueTailIndex;
+	FP             CurrentEnergy;
+	FP             EnergyFillRate;
+	FP             MaxEnergy;
+	FP             NextFillTime;
+	list<CardInfo> CardQueue;
+	list<CardInfo> AvailableCards;
+}
+
+struct CardInfo
+{
+	AssetRefCardSettings CardSettings;
+	Byte                 Level;
+}
+
+[PreserveInPrototype]
+enum ERarity : byte
+{
+	Common,
+	Uncommon,
+	Rare,
+	Epic,
+	Legendary,
+}
+
+synced event CardsChanged
+{
+	EntityRef Entity;
+}

data/CardManagerSystem.cs

@@ -0,0 +1,38 @@
+namespace Quantum
+{
+	using Photon.Deterministic;
+
+	unsafe class CardManagerSystem : SystemMainThread
+	{
+		public override void Update(Frame frame)
+		{
+			foreach (var pair in frame.Unsafe.GetComponentBlockIterator<CardManager>())
+			{
+				pair.Component->Update(frame, pair.Entity);
+			}
+
+			var gameplay = frame.Unsafe.GetPointerSingleton<Gameplay>();
+			if (gameplay->IsActive == false)
+				return;
+
+			foreach (var pair in frame.Unsafe.GetComponentBlockIterator<Player>())
+			{
+				var command = frame.GetPlayerCommand(pair.Component->PlayerRef);
+				switch (command)
+				{
+					case UseCardCommand useCard:
+						ProcessCommand(frame, pair.Entity, pair.Component->PlayerRef, useCard);
+						break;
+				}
+			}
+		}
+
+		// PRIVATE METHODS
+
+		private void ProcessCommand(Frame frame, EntityRef entity, PlayerRef playerRef, UseCardCommand useCard)
+		{
+			var cardManager = frame.Unsafe.GetPointer<CardManager>(entity);
+			cardManager->UseCard(frame, entity, playerRef, useCard.CardIndex, useCard.Position, playerRef * FP.Rad_180);
+		}
+	}
+}

data/CardSettings.cs

@@ -0,0 +1,14 @@
+namespace Quantum
+{
+	using Photon.Deterministic;
+	using Quantum.Inspector;
+
+	public abstract partial class CardSettings
+	{
+		[Header("Card")]
+		public AssetRefEntityPrototype  Prefab;
+		public ERarity                  Rarity;
+		public byte                     EnergyCost;
+		public FP                       ActivationDelay;
+	}
+}

data/Chain.User.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	unsafe partial struct Chain
+	{
+		public void Update(FrameThreadSafe frame, ref ChainSystem.Filter filter)
+		{
+			FPVector3 direction = filter.Transform->Position - LastPosition;
+			Alpha = direction.Magnitude / DistanceThreshold;
+
+			// cycle element
+			if (Alpha > FP._1)
+			{
+				Alpha = Alpha % FP._1;
+				AddBreadCrumb(direction);
+			}
+
+			filter.Body->Drag = MinDrag + Count * DragPerItem;
+			if (filter.Drivable->Grounded == false) filter.Body->GravityScale = FP._1;
+			filter.Drivable->Grounded = false;
+#if DEBUG
+			for (int i = 0; i < Positions.Length; i++)
+			{
+				Draw.Sphere(Positions[i], FP._0_10, ColorRGBA.ColliderBlue);
+			}
+#endif
+		}
+
+		public void AddBreadCrumb(FPVector3 direction)
+		{
+			FPVector3 newPosition = LastPosition + direction.Normalized * DistanceThreshold;
+			*Positions.GetPointer(Current) = newPosition;
+			Current = (Current + 1) % Positions.Length;
+			LastPosition = newPosition;
+		}
+	}
+}

data/ChainItem.cs

@@ -0,0 +1,41 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+  unsafe partial struct ChainItem
+  {
+    public void Update(FrameThreadSafe frame, ref ChainItemSystem.Filter filter)
+    {
+      // READ-ONLY for this component, PLEASE
+      if (frame.TryGetPointer<Chain>(Chain, out var chain))
+      {
+        if (chain->Count <= Index)
+        {
+          Destroy = true;
+          return;
+        }
+        
+        int indexFrom = (chain->Current - Index + chain->Positions.Length - 2) % chain->Positions.Length;
+        int indexTo = (indexFrom + 1) % chain->Positions.Length;
+        FPVector3 from = chain->Positions[indexFrom];
+        FPVector3 to = chain->Positions[indexTo];
+        FPVector3 position = FPVector3.Lerp(from, to, chain->Alpha);
+        filter.Transform->Position = position;
+
+        FPVector3 direction = (to - from).Normalized;
+        FPQuaternion desiredRotation = FPQuaternion.LookRotation(direction);
+        FP angle = FPQuaternion.Angle(desiredRotation, filter.Transform->Rotation);
+        if (angle < SnapAngle)
+        {
+          filter.Transform->Rotation = FPQuaternion.RotateTowards(filter.Transform->Rotation, desiredRotation, RotationSpeed * frame.DeltaTime);
+        }
+        else
+        {
+          filter.Transform->Rotation = desiredRotation;
+        }
+        
+      }
+    }
+  }
+}

data/ChainItemSystem.cs

@@ -0,0 +1,20 @@
+using System;
+using Photon.Deterministic;
+using Quantum.Task;
+
+namespace Quantum
+{
+	public unsafe class ChainItemSystem : SystemThreadedFilter<ChainItemSystem.Filter>
+	{
+		public struct Filter
+		{
+			public EntityRef Entity;
+			public Transform3D* Transform;
+			public ChainItem* Item;
+		}
+		public override void Update(FrameThreadSafe frame, ref Filter filter)
+		{
+			filter.Item->Update(frame, ref filter);
+		}
+	}
+}

data/ChainSystem.cs

@@ -0,0 +1,72 @@
+using System;
+using Photon.Deterministic;
+using Quantum.Task;
+
+namespace Quantum
+{
+	public unsafe class ChainSystem : SystemThreadedFilter<ChainSystem.Filter>, ISignalOnTrigger3D, ISignalOnCollision3D, ISignalOnComponentAdded<Chain>
+	{
+		public struct Filter
+		{
+			public EntityRef Entity;
+			public Transform3D* Transform;
+			public PhysicsBody3D* Body;
+			public Chain* Chain;
+			public Drivable* Drivable;
+		}
+
+		public void OnAdded(Frame frame, EntityRef entity, Chain* chain)
+		{
+			Transform3D transform = frame.Get<Transform3D>(entity);
+			chain->LastPosition = transform.Position;
+			for (int i = 0; i < 5; i++)
+			{
+				chain->AddBreadCrumb(transform.Back);
+			}
+		}
+
+		public void OnTrigger3D(Frame frame, TriggerInfo3D info)
+		{
+			if (frame.Unsafe.TryGetPointer<Pickup>(info.Other, out var pickup) && frame.Unsafe.TryGetPointer<Chain>(info.Entity, out var chain))
+			{
+				EntityRef entity = frame.Create(pickup->ItemPrototype);
+				if (frame.Unsafe.TryGetPointer<ChainItem>(entity, out var item))
+				{
+					int index = chain->Count++;
+					item->Chain = info.Entity;
+					item->Index = index;
+				}
+				if (frame.Unsafe.TryGetPointerSingleton<PickupSpawner>(out var spawner))
+				{
+					spawner->Count--;
+				}
+				frame.Destroy(info.Other);
+			}
+		}
+
+		public void OnCollision3D(Frame frame, CollisionInfo3D info)
+		{
+			if (frame.Unsafe.TryGetPointer<Drivable>(info.Entity, out var drivable) && frame.Unsafe.TryGetPointer<PhysicsBody3D>(info.Entity, out var body))
+			{
+				FP angle = FPVector3.Angle(info.ContactNormal, FPVector3.Up);
+				if (angle < 45)
+				{
+					drivable->Grounded = true;
+					drivable->SurfaceNormal = info.ContactNormal;
+					body->GravityScale = FP._0;
+				}
+			}
+
+			if (frame.Unsafe.TryGetPointer<ChainItem>(info.Other, out var item) && frame.Unsafe.TryGetPointer<Chain>(item->Chain, out var chain))
+			{
+				chain->Count = Math.Min(item->Index, chain->Count);
+				info.IgnoreCollision = true;
+			}
+		}
+
+		public override void Update(FrameThreadSafe frame, ref Filter filter)
+		{
+			filter.Chain->Update(frame, ref filter);
+		}
+	}
+}

data/CheckIndicatorView.cs

@@ -0,0 +1,34 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Quantum;
+
+public class CheckIndicatorView : QuantumCallbacks {
+
+  public GameObject Indicator;
+  public PieceView Piece;
+
+	void Start () {
+    Indicator.SetActive(false);
+    QuantumEvent.Subscribe<EventPlayerInCheck>(this, SetCheckIndicator);
+    QuantumEvent.Subscribe<EventTurnEnded>(this, ResetCheckIndicator);
+  }
+
+  private void SetCheckIndicator(EventPlayerInCheck e)
+  {
+    if (e.Color == Piece.Color)
+    {
+      Indicator.SetActive(true);
+    }
+  }
+
+  private void ResetCheckIndicator(EventTurnEnded e)
+  {
+    Indicator.SetActive(false);
+  }
+
+  protected override void OnDisable()
+  {
+    QuantumEvent.UnsubscribeListener(this);
+  }
+}

data/ChecksumVerification.cs

@@ -0,0 +1,52 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Quantum {
+  public class ChecksumVerification : IDisposable {
+    private Dictionary<int, ChecksumFile.ChecksumEntry> _checksums;
+    private Quantum.CallbackDispatcher _gameCallbacks;
+    private bool _verbose;
+
+    public ChecksumVerification(string pathToChecksumFile, Quantum.CallbackDispatcher callbacks, bool verbose = false) {
+      _checksums = JsonConvert.DeserializeObject<ChecksumFile>(File.ReadAllText(pathToChecksumFile), ReplayJsonSerializerSettings.GetSettings()).ToDictionary();
+      _gameCallbacks = callbacks;
+      _gameCallbacks.Subscribe(this, (CallbackSimulateFinished callback) => OnSimulateFinished(callback.Game, callback.Frame));
+      _verbose = verbose;
+    }
+
+    private void OnSimulateFinished(QuantumGame game, Frame frame) {
+      if (frame != null) {
+        var f = frame.Number;
+        var cs = ChecksumFileHelper.UlongToLong(frame.CalculateChecksum());
+
+        if (_checksums != null) {
+
+          if (_checksums.ContainsKey(f)) {
+            Console.Write($"{f,6} {cs,25} ");
+            if (cs != _checksums[f].ChecksumAsLong) {
+              Console.ForegroundColor = ConsoleColor.Red;
+              Console.Write("(failed)");
+            } else {
+              Console.ForegroundColor = ConsoleColor.Green;
+              Console.Write("(verified)");
+            }
+            Console.Write("\n");
+          } else if (_verbose) {
+            Console.Write($"{f,6} {cs,25} ");
+            Console.Write("(skipped)");
+          }
+          Console.ForegroundColor = ConsoleColor.Gray;
+        }
+      }
+    }
+
+    public void Dispose() {
+      if (_gameCallbacks != null) {
+        _gameCallbacks.UnsubscribeListener(this);
+        _gameCallbacks = null;
+      }
+    }
+  }
+}

data/ChessViewUpdater.cs

@@ -0,0 +1,148 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Quantum;
+
+public unsafe class ChessViewUpdater : QuantumCallbacks
+{
+  public static ChessViewUpdater Instance;
+
+  public PieceView[] Pieces = new PieceView[32];
+
+  public Vector3 PieceOffset = new Vector3(.5f, 0, .5f);
+
+  public GameObject LastMoveIdicatorInitial;
+  public GameObject LastMoveIdicatorTarget;
+
+  public Sprite WhiteQueenSprite;
+  public Sprite WhiteRookSprite;
+  public Sprite WhiteKnightSprite;
+  public Sprite WhiteBishopSprite;
+  //
+  public Sprite BlackQueenSprite;
+  public Sprite BlackRookSprite;
+  public Sprite BlackKnightSprite;
+  public Sprite BlackBishopSprite;
+
+  public DeadPiecesManager DeadPieces;
+
+  private bool _initialized = false;
+
+
+  public void Start()
+  {
+    if (Instance == null)
+    {
+      Instance = this;
+    }
+
+    QuantumEvent.Subscribe<EventChangePiecePosition>(this, UpdatePiece);
+    QuantumEvent.Subscribe<EventRemovePiece>(this, RemovePiece);
+    QuantumEvent.Subscribe<EventPiecePromotion>(this, PiecePromotion);
+  }
+
+  public override void OnUpdateView(QuantumGame game)
+  {
+    if (!_initialized)
+    {
+      _initialized = true;
+      var f = game.Frames.Verified;
+      for (int i = 0; i < f.Global->Board.Cells.Length; i++)
+      {
+        int index = GetPieceIndex(i);
+        if (index != -1)
+        {
+          var p = Pieces[index];
+          var position = BoardHelper.GetCordinatesByIndex(p.IndexOnBoard);
+          p.SetTargetPosition(new Vector3((float)position.X + PieceOffset.x, PieceOffset.x, (float)position.Y + PieceOffset.z));
+        }
+      }
+    }
+  }
+
+  public void PiecePromotion(EventPiecePromotion e)
+  {
+    var index = GetPieceIndex(e.Index);
+    Pieces[index].Type = e.NewType;
+    switch (e.NewType)
+    {
+      case PieceType.Bishop:
+        if (Pieces[index].Color == PieceColor.White)
+          Pieces[index].GetComponent<SpriteRenderer>().sprite = WhiteBishopSprite;
+        else
+          Pieces[index].GetComponent<SpriteRenderer>().sprite = BlackBishopSprite;
+        break;
+      case PieceType.Knight:
+        if (Pieces[index].Color == PieceColor.White)
+          Pieces[index].GetComponent<SpriteRenderer>().sprite = WhiteKnightSprite;
+        else
+          Pieces[index].GetComponent<SpriteRenderer>().sprite = BlackKnightSprite;
+        break;
+      case PieceType.Queen:
+        if (Pieces[index].Color == PieceColor.White)
+          Pieces[index].GetComponent<SpriteRenderer>().sprite = WhiteQueenSprite;
+        else
+          Pieces[index].GetComponent<SpriteRenderer>().sprite = BlackQueenSprite;
+        break;
+      case PieceType.Rook:
+        if (Pieces[index].Color == PieceColor.White)
+          Pieces[index].GetComponent<SpriteRenderer>().sprite = WhiteRookSprite;
+        else
+          Pieces[index].GetComponent<SpriteRenderer>().sprite = BlackRookSprite;
+        break;
+    }
+  }
+
+  public void UpdatePiece(EventChangePiecePosition e)
+  {
+    var origin = (int)e.Index.X;
+    var target = (int)e.Index.Y;
+
+    SetObjectByIndex(LastMoveIdicatorInitial, origin);
+    SetObjectByIndex(LastMoveIdicatorTarget, target);
+
+    int index = GetPieceIndex(origin);
+    if (index != -1)
+    {
+      var p = Pieces[index];
+      p.IndexOnBoard = target;
+      var position = BoardHelper.GetCordinatesByIndex(p.IndexOnBoard);
+      p.SetTargetPosition(new Vector3((float)position.X + PieceOffset.x, PieceOffset.x, (float)position.Y + PieceOffset.z));
+    }
+  }
+
+  public void SetObjectByIndex(GameObject go, int index)
+  {
+    var position = BoardHelper.GetCordinatesByIndex(index);
+    go.transform.position = new Vector3((float)position.X + PieceOffset.x, PieceOffset.y, (float)position.Y + PieceOffset.z);
+    go.SetActive(true);
+  }
+
+  public void RemovePiece(EventRemovePiece e)
+  {
+    var index = GetPieceIndex(e.Index);
+    DeadPieces.StoreDeadPiece(Pieces[index], e.Color);
+    Pieces[index].IndexOnBoard = -1;
+  }
+
+  public int GetPieceIndex(int index)
+  {
+    for (int i = 0; i < Pieces.Length; i++)
+    {
+      if (Pieces[i] == null)
+      {
+        continue;
+      }
+      if (Pieces[i].IndexOnBoard == index)
+      {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  public void OnDisable()
+  {
+    QuantumEvent.UnsubscribeListener(this);
+  }
+}

data/CodeGen.cs

@@ -0,0 +1,1995 @@
+// <auto-generated>
+// This code was auto-generated by a tool, every time
+// the tool executes this code will be reset.
+//
+// If you need to extend the classes generated to add
+// fields or methods to them, please create partial
+// declarations in another file.
+// </auto-generated>
+#pragma warning disable 0649
+#pragma warning disable 1522
+#pragma warning disable 0414
+#pragma warning disable 0219
+#pragma warning disable 0109
+
+namespace Quantum {
+  using System;
+  using System.Collections.Generic;
+  using System.Runtime.InteropServices;
+  using Photon.Deterministic;
+  using Quantum.Core;
+  using Quantum.Collections;
+  using Quantum.Inspector;
+  using Quantum.Physics2D;
+  using Quantum.Physics3D;
+  using Optional = Quantum.Inspector.OptionalAttribute;
+  using MethodImplAttribute = System.Runtime.CompilerServices.MethodImplAttribute;
+  using MethodImplOptions = System.Runtime.CompilerServices.MethodImplOptions;
+  
+  public enum TurnEndReason : int {
+    Time,
+    Skip,
+    Play,
+    Resolved,
+  }
+  public enum TurnStatus : int {
+    Inactive,
+    Active,
+    Resolving,
+  }
+  public enum TurnType : int {
+    Play,
+    Countdown,
+  }
+  [System.FlagsAttribute()]
+  public enum InputButtons : int {
+  }
+  public static unsafe partial class InputButtons_ext {
+    public static Boolean IsFlagSet(this InputButtons self, InputButtons flag) {
+      return (self & flag) == flag;
+    }
+    public static InputButtons SetFlag(this InputButtons self, InputButtons flag) {
+      return self | flag;
+    }
+    public static InputButtons ClearFlag(this InputButtons self, InputButtons flag) {
+      return self & ~flag;
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct BitSet1024 {
+    public const Int32 SIZE = 128;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    private fixed UInt64 bits[16];
+    public const Int32 BitsSize = 1024;
+    public Int32 Length {
+      get {
+        return 1024;
+      }
+    }
+    public static void Print(void* ptr, FramePrinter printer) {
+      var p = (BitSet1024*)ptr;
+      printer.ScopeBegin();
+      UnmanagedUtils.PrintBytesBits((byte*)&p->bits, 1024, 64, printer);
+      printer.ScopeEnd();
+    }
+    [System.ObsoleteAttribute("Use instance Set method instead")]
+    public static void Set(BitSet1024* set, Int32 bit) {
+      set->bits[bit/64] |= (1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance Clear method instead")]
+    public static void Clear(BitSet1024* set, Int32 bit) {
+      set->bits[bit/64] &= ~(1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance ClearAll method instead")]
+    public static void ClearAll(BitSet1024* set) {
+      Native.Utils.Clear(&set->bits[0], 128);
+    }
+    [System.ObsoleteAttribute("Use instance IsSet method instead")]
+    public static Boolean IsSet(BitSet1024* set, Int32 bit) {
+      return (set->bits[bit/64]&(1UL<<(bit%64))) != 0UL;
+    }
+    public static BitSet1024 FromArray(UInt64[] values) {
+      Assert.Always(16 == values.Length);
+      BitSet1024 result = default;
+      for (int i = 0; i < 16; ++i) {
+        result.bits[i] = values[i];
+      }
+      return result;
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 1024);
+      fixed (UInt64* p = bits) (p[bit/64]) |= (1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Clear(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 1024);
+      fixed (UInt64* p = bits) (p[bit/64]) &= ~(1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ClearAll() {
+      fixed (UInt64* p = bits) Native.Utils.Clear(p, 128);
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Boolean IsSet(Int32 bit) {
+      fixed (UInt64* p = bits) return ((p[bit/64])&(1UL<<(bit%64))) != 0UL;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 37;
+        fixed (UInt64* p = bits) hash = hash * 31 + HashCodeUtils.GetArrayHashCode(p, 16);
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (BitSet1024*)ptr;
+        serializer.Stream.SerializeBuffer(&p->bits[0], 16);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct BitSet128 {
+    public const Int32 SIZE = 16;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    private fixed UInt64 bits[2];
+    public const Int32 BitsSize = 128;
+    public Int32 Length {
+      get {
+        return 128;
+      }
+    }
+    public static void Print(void* ptr, FramePrinter printer) {
+      var p = (BitSet128*)ptr;
+      printer.ScopeBegin();
+      UnmanagedUtils.PrintBytesBits((byte*)&p->bits, 128, 64, printer);
+      printer.ScopeEnd();
+    }
+    [System.ObsoleteAttribute("Use instance Set method instead")]
+    public static void Set(BitSet128* set, Int32 bit) {
+      set->bits[bit/64] |= (1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance Clear method instead")]
+    public static void Clear(BitSet128* set, Int32 bit) {
+      set->bits[bit/64] &= ~(1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance ClearAll method instead")]
+    public static void ClearAll(BitSet128* set) {
+      Native.Utils.Clear(&set->bits[0], 16);
+    }
+    [System.ObsoleteAttribute("Use instance IsSet method instead")]
+    public static Boolean IsSet(BitSet128* set, Int32 bit) {
+      return (set->bits[bit/64]&(1UL<<(bit%64))) != 0UL;
+    }
+    public static BitSet128 FromArray(UInt64[] values) {
+      Assert.Always(2 == values.Length);
+      BitSet128 result = default;
+      for (int i = 0; i < 2; ++i) {
+        result.bits[i] = values[i];
+      }
+      return result;
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 128);
+      fixed (UInt64* p = bits) (p[bit/64]) |= (1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Clear(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 128);
+      fixed (UInt64* p = bits) (p[bit/64]) &= ~(1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ClearAll() {
+      fixed (UInt64* p = bits) Native.Utils.Clear(p, 16);
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Boolean IsSet(Int32 bit) {
+      fixed (UInt64* p = bits) return ((p[bit/64])&(1UL<<(bit%64))) != 0UL;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 41;
+        fixed (UInt64* p = bits) hash = hash * 31 + HashCodeUtils.GetArrayHashCode(p, 2);
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (BitSet128*)ptr;
+        serializer.Stream.SerializeBuffer(&p->bits[0], 2);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct BitSet2 {
+    public const Int32 SIZE = 8;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    private fixed UInt64 bits[1];
+    public const Int32 BitsSize = 2;
+    public Int32 Length {
+      get {
+        return 2;
+      }
+    }
+    public static void Print(void* ptr, FramePrinter printer) {
+      var p = (BitSet2*)ptr;
+      printer.ScopeBegin();
+      UnmanagedUtils.PrintBytesBits((byte*)&p->bits, 2, 64, printer);
+      printer.ScopeEnd();
+    }
+    [System.ObsoleteAttribute("Use instance Set method instead")]
+    public static void Set(BitSet2* set, Int32 bit) {
+      set->bits[bit/64] |= (1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance Clear method instead")]
+    public static void Clear(BitSet2* set, Int32 bit) {
+      set->bits[bit/64] &= ~(1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance ClearAll method instead")]
+    public static void ClearAll(BitSet2* set) {
+      Native.Utils.Clear(&set->bits[0], 8);
+    }
+    [System.ObsoleteAttribute("Use instance IsSet method instead")]
+    public static Boolean IsSet(BitSet2* set, Int32 bit) {
+      return (set->bits[bit/64]&(1UL<<(bit%64))) != 0UL;
+    }
+    public static BitSet2 FromArray(UInt64[] values) {
+      Assert.Always(1 == values.Length);
+      BitSet2 result = default;
+      for (int i = 0; i < 1; ++i) {
+        result.bits[i] = values[i];
+      }
+      return result;
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 2);
+      fixed (UInt64* p = bits) (p[bit/64]) |= (1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Clear(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 2);
+      fixed (UInt64* p = bits) (p[bit/64]) &= ~(1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ClearAll() {
+      fixed (UInt64* p = bits) Native.Utils.Clear(p, 8);
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Boolean IsSet(Int32 bit) {
+      fixed (UInt64* p = bits) return ((p[bit/64])&(1UL<<(bit%64))) != 0UL;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 43;
+        fixed (UInt64* p = bits) hash = hash * 31 + HashCodeUtils.GetArrayHashCode(p, 1);
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (BitSet2*)ptr;
+        serializer.Stream.SerializeBuffer(&p->bits[0], 1);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct BitSet2048 {
+    public const Int32 SIZE = 256;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    private fixed UInt64 bits[32];
+    public const Int32 BitsSize = 2048;
+    public Int32 Length {
+      get {
+        return 2048;
+      }
+    }
+    public static void Print(void* ptr, FramePrinter printer) {
+      var p = (BitSet2048*)ptr;
+      printer.ScopeBegin();
+      UnmanagedUtils.PrintBytesBits((byte*)&p->bits, 2048, 64, printer);
+      printer.ScopeEnd();
+    }
+    [System.ObsoleteAttribute("Use instance Set method instead")]
+    public static void Set(BitSet2048* set, Int32 bit) {
+      set->bits[bit/64] |= (1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance Clear method instead")]
+    public static void Clear(BitSet2048* set, Int32 bit) {
+      set->bits[bit/64] &= ~(1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance ClearAll method instead")]
+    public static void ClearAll(BitSet2048* set) {
+      Native.Utils.Clear(&set->bits[0], 256);
+    }
+    [System.ObsoleteAttribute("Use instance IsSet method instead")]
+    public static Boolean IsSet(BitSet2048* set, Int32 bit) {
+      return (set->bits[bit/64]&(1UL<<(bit%64))) != 0UL;
+    }
+    public static BitSet2048 FromArray(UInt64[] values) {
+      Assert.Always(32 == values.Length);
+      BitSet2048 result = default;
+      for (int i = 0; i < 32; ++i) {
+        result.bits[i] = values[i];
+      }
+      return result;
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 2048);
+      fixed (UInt64* p = bits) (p[bit/64]) |= (1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Clear(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 2048);
+      fixed (UInt64* p = bits) (p[bit/64]) &= ~(1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ClearAll() {
+      fixed (UInt64* p = bits) Native.Utils.Clear(p, 256);
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Boolean IsSet(Int32 bit) {
+      fixed (UInt64* p = bits) return ((p[bit/64])&(1UL<<(bit%64))) != 0UL;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 47;
+        fixed (UInt64* p = bits) hash = hash * 31 + HashCodeUtils.GetArrayHashCode(p, 32);
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (BitSet2048*)ptr;
+        serializer.Stream.SerializeBuffer(&p->bits[0], 32);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct BitSet256 {
+    public const Int32 SIZE = 32;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    private fixed UInt64 bits[4];
+    public const Int32 BitsSize = 256;
+    public Int32 Length {
+      get {
+        return 256;
+      }
+    }
+    public static void Print(void* ptr, FramePrinter printer) {
+      var p = (BitSet256*)ptr;
+      printer.ScopeBegin();
+      UnmanagedUtils.PrintBytesBits((byte*)&p->bits, 256, 64, printer);
+      printer.ScopeEnd();
+    }
+    [System.ObsoleteAttribute("Use instance Set method instead")]
+    public static void Set(BitSet256* set, Int32 bit) {
+      set->bits[bit/64] |= (1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance Clear method instead")]
+    public static void Clear(BitSet256* set, Int32 bit) {
+      set->bits[bit/64] &= ~(1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance ClearAll method instead")]
+    public static void ClearAll(BitSet256* set) {
+      Native.Utils.Clear(&set->bits[0], 32);
+    }
+    [System.ObsoleteAttribute("Use instance IsSet method instead")]
+    public static Boolean IsSet(BitSet256* set, Int32 bit) {
+      return (set->bits[bit/64]&(1UL<<(bit%64))) != 0UL;
+    }
+    public static BitSet256 FromArray(UInt64[] values) {
+      Assert.Always(4 == values.Length);
+      BitSet256 result = default;
+      for (int i = 0; i < 4; ++i) {
+        result.bits[i] = values[i];
+      }
+      return result;
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 256);
+      fixed (UInt64* p = bits) (p[bit/64]) |= (1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Clear(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 256);
+      fixed (UInt64* p = bits) (p[bit/64]) &= ~(1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ClearAll() {
+      fixed (UInt64* p = bits) Native.Utils.Clear(p, 32);
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Boolean IsSet(Int32 bit) {
+      fixed (UInt64* p = bits) return ((p[bit/64])&(1UL<<(bit%64))) != 0UL;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 53;
+        fixed (UInt64* p = bits) hash = hash * 31 + HashCodeUtils.GetArrayHashCode(p, 4);
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (BitSet256*)ptr;
+        serializer.Stream.SerializeBuffer(&p->bits[0], 4);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct BitSet4096 {
+    public const Int32 SIZE = 512;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    private fixed UInt64 bits[64];
+    public const Int32 BitsSize = 4096;
+    public Int32 Length {
+      get {
+        return 4096;
+      }
+    }
+    public static void Print(void* ptr, FramePrinter printer) {
+      var p = (BitSet4096*)ptr;
+      printer.ScopeBegin();
+      UnmanagedUtils.PrintBytesBits((byte*)&p->bits, 4096, 64, printer);
+      printer.ScopeEnd();
+    }
+    [System.ObsoleteAttribute("Use instance Set method instead")]
+    public static void Set(BitSet4096* set, Int32 bit) {
+      set->bits[bit/64] |= (1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance Clear method instead")]
+    public static void Clear(BitSet4096* set, Int32 bit) {
+      set->bits[bit/64] &= ~(1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance ClearAll method instead")]
+    public static void ClearAll(BitSet4096* set) {
+      Native.Utils.Clear(&set->bits[0], 512);
+    }
+    [System.ObsoleteAttribute("Use instance IsSet method instead")]
+    public static Boolean IsSet(BitSet4096* set, Int32 bit) {
+      return (set->bits[bit/64]&(1UL<<(bit%64))) != 0UL;
+    }
+    public static BitSet4096 FromArray(UInt64[] values) {
+      Assert.Always(64 == values.Length);
+      BitSet4096 result = default;
+      for (int i = 0; i < 64; ++i) {
+        result.bits[i] = values[i];
+      }
+      return result;
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 4096);
+      fixed (UInt64* p = bits) (p[bit/64]) |= (1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Clear(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 4096);
+      fixed (UInt64* p = bits) (p[bit/64]) &= ~(1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ClearAll() {
+      fixed (UInt64* p = bits) Native.Utils.Clear(p, 512);
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Boolean IsSet(Int32 bit) {
+      fixed (UInt64* p = bits) return ((p[bit/64])&(1UL<<(bit%64))) != 0UL;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 59;
+        fixed (UInt64* p = bits) hash = hash * 31 + HashCodeUtils.GetArrayHashCode(p, 64);
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (BitSet4096*)ptr;
+        serializer.Stream.SerializeBuffer(&p->bits[0], 64);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct BitSet512 {
+    public const Int32 SIZE = 64;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    private fixed UInt64 bits[8];
+    public const Int32 BitsSize = 512;
+    public Int32 Length {
+      get {
+        return 512;
+      }
+    }
+    public static void Print(void* ptr, FramePrinter printer) {
+      var p = (BitSet512*)ptr;
+      printer.ScopeBegin();
+      UnmanagedUtils.PrintBytesBits((byte*)&p->bits, 512, 64, printer);
+      printer.ScopeEnd();
+    }
+    [System.ObsoleteAttribute("Use instance Set method instead")]
+    public static void Set(BitSet512* set, Int32 bit) {
+      set->bits[bit/64] |= (1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance Clear method instead")]
+    public static void Clear(BitSet512* set, Int32 bit) {
+      set->bits[bit/64] &= ~(1UL<<(bit%64));
+    }
+    [System.ObsoleteAttribute("Use instance ClearAll method instead")]
+    public static void ClearAll(BitSet512* set) {
+      Native.Utils.Clear(&set->bits[0], 64);
+    }
+    [System.ObsoleteAttribute("Use instance IsSet method instead")]
+    public static Boolean IsSet(BitSet512* set, Int32 bit) {
+      return (set->bits[bit/64]&(1UL<<(bit%64))) != 0UL;
+    }
+    public static BitSet512 FromArray(UInt64[] values) {
+      Assert.Always(8 == values.Length);
+      BitSet512 result = default;
+      for (int i = 0; i < 8; ++i) {
+        result.bits[i] = values[i];
+      }
+      return result;
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 512);
+      fixed (UInt64* p = bits) (p[bit/64]) |= (1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Clear(Int32 bit) {
+      Assert.Check(bit >= 0 && bit < 512);
+      fixed (UInt64* p = bits) (p[bit/64]) &= ~(1UL<<(bit%64));
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ClearAll() {
+      fixed (UInt64* p = bits) Native.Utils.Clear(p, 64);
+    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Boolean IsSet(Int32 bit) {
+      fixed (UInt64* p = bits) return ((p[bit/64])&(1UL<<(bit%64))) != 0UL;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 61;
+        fixed (UInt64* p = bits) hash = hash * 31 + HashCodeUtils.GetArrayHashCode(p, 8);
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (BitSet512*)ptr;
+        serializer.Stream.SerializeBuffer(&p->bits[0], 8);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  [Quantum.AssetRefAttribute(typeof(BallPoolSpec))]
+  [System.SerializableAttribute()]
+  public unsafe partial struct AssetRefBallPoolSpec : IEquatable<AssetRefBallPoolSpec>, IAssetRef<BallPoolSpec> {
+    public const Int32 SIZE = 8;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    public AssetGuid Id;
+    public override String ToString() {
+      return AssetRef.ToString(Id);
+    }
+    public static implicit operator AssetRefBallPoolSpec(BallPoolSpec value) {
+      var r = default(AssetRefBallPoolSpec);
+      if (value != null) {
+        r.Id = value.Guid;
+      }
+      return r;
+    }
+    public override Boolean Equals(Object obj) {
+      return obj is AssetRefBallPoolSpec other && Equals(other);
+    }
+    public Boolean Equals(AssetRefBallPoolSpec other) {
+      return Id.Equals(other.Id);
+    }
+    public static Boolean operator ==(AssetRefBallPoolSpec a, AssetRefBallPoolSpec b) {
+      return a.Id == b.Id;
+    }
+    public static Boolean operator !=(AssetRefBallPoolSpec a, AssetRefBallPoolSpec b) {
+      return a.Id != b.Id;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 67;
+        hash = hash * 31 + Id.GetHashCode();
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (AssetRefBallPoolSpec*)ptr;
+        AssetGuid.Serialize(&p->Id, serializer);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  [Quantum.AssetRefAttribute(typeof(ConfigAssets))]
+  [System.SerializableAttribute()]
+  public unsafe partial struct AssetRefConfigAssets : IEquatable<AssetRefConfigAssets>, IAssetRef<ConfigAssets> {
+    public const Int32 SIZE = 8;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    public AssetGuid Id;
+    public override String ToString() {
+      return AssetRef.ToString(Id);
+    }
+    public static implicit operator AssetRefConfigAssets(ConfigAssets value) {
+      var r = default(AssetRefConfigAssets);
+      if (value != null) {
+        r.Id = value.Guid;
+      }
+      return r;
+    }
+    public override Boolean Equals(Object obj) {
+      return obj is AssetRefConfigAssets other && Equals(other);
+    }
+    public Boolean Equals(AssetRefConfigAssets other) {
+      return Id.Equals(other.Id);
+    }
+    public static Boolean operator ==(AssetRefConfigAssets a, AssetRefConfigAssets b) {
+      return a.Id == b.Id;
+    }
+    public static Boolean operator !=(AssetRefConfigAssets a, AssetRefConfigAssets b) {
+      return a.Id != b.Id;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 71;
+        hash = hash * 31 + Id.GetHashCode();
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (AssetRefConfigAssets*)ptr;
+        AssetGuid.Serialize(&p->Id, serializer);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  [Quantum.AssetRefAttribute(typeof(GameConfig))]
+  [System.SerializableAttribute()]
+  public unsafe partial struct AssetRefGameConfig : IEquatable<AssetRefGameConfig>, IAssetRef<GameConfig> {
+    public const Int32 SIZE = 8;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    public AssetGuid Id;
+    public override String ToString() {
+      return AssetRef.ToString(Id);
+    }
+    public static implicit operator AssetRefGameConfig(GameConfig value) {
+      var r = default(AssetRefGameConfig);
+      if (value != null) {
+        r.Id = value.Guid;
+      }
+      return r;
+    }
+    public override Boolean Equals(Object obj) {
+      return obj is AssetRefGameConfig other && Equals(other);
+    }
+    public Boolean Equals(AssetRefGameConfig other) {
+      return Id.Equals(other.Id);
+    }
+    public static Boolean operator ==(AssetRefGameConfig a, AssetRefGameConfig b) {
+      return a.Id == b.Id;
+    }
+    public static Boolean operator !=(AssetRefGameConfig a, AssetRefGameConfig b) {
+      return a.Id != b.Id;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 73;
+        hash = hash * 31 + Id.GetHashCode();
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (AssetRefGameConfig*)ptr;
+        AssetGuid.Serialize(&p->Id, serializer);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  [Quantum.AssetRefAttribute(typeof(TurnConfig))]
+  [System.SerializableAttribute()]
+  public unsafe partial struct AssetRefTurnConfig : IEquatable<AssetRefTurnConfig>, IAssetRef<TurnConfig> {
+    public const Int32 SIZE = 8;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    public AssetGuid Id;
+    public override String ToString() {
+      return AssetRef.ToString(Id);
+    }
+    public static implicit operator AssetRefTurnConfig(TurnConfig value) {
+      var r = default(AssetRefTurnConfig);
+      if (value != null) {
+        r.Id = value.Guid;
+      }
+      return r;
+    }
+    public override Boolean Equals(Object obj) {
+      return obj is AssetRefTurnConfig other && Equals(other);
+    }
+    public Boolean Equals(AssetRefTurnConfig other) {
+      return Id.Equals(other.Id);
+    }
+    public static Boolean operator ==(AssetRefTurnConfig a, AssetRefTurnConfig b) {
+      return a.Id == b.Id;
+    }
+    public static Boolean operator !=(AssetRefTurnConfig a, AssetRefTurnConfig b) {
+      return a.Id != b.Id;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 79;
+        hash = hash * 31 + Id.GetHashCode();
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (AssetRefTurnConfig*)ptr;
+        AssetGuid.Serialize(&p->Id, serializer);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  [Quantum.AssetRefAttribute(typeof(UserMap))]
+  [System.SerializableAttribute()]
+  public unsafe partial struct AssetRefUserMap : IEquatable<AssetRefUserMap>, IAssetRef<UserMap> {
+    public const Int32 SIZE = 8;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    public AssetGuid Id;
+    public override String ToString() {
+      return AssetRef.ToString(Id);
+    }
+    public static implicit operator AssetRefUserMap(UserMap value) {
+      var r = default(AssetRefUserMap);
+      if (value != null) {
+        r.Id = value.Guid;
+      }
+      return r;
+    }
+    public override Boolean Equals(Object obj) {
+      return obj is AssetRefUserMap other && Equals(other);
+    }
+    public Boolean Equals(AssetRefUserMap other) {
+      return Id.Equals(other.Id);
+    }
+    public static Boolean operator ==(AssetRefUserMap a, AssetRefUserMap b) {
+      return a.Id == b.Id;
+    }
+    public static Boolean operator !=(AssetRefUserMap a, AssetRefUserMap b) {
+      return a.Id != b.Id;
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 83;
+        hash = hash * 31 + Id.GetHashCode();
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (AssetRefUserMap*)ptr;
+        AssetGuid.Serialize(&p->Id, serializer);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct BallPoolPlayer {
+    public const Int32 SIZE = 48;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(0)]
+    public PlayerRef Ref;
+    [FieldOffset(4)]
+    public QBoolean StripedBalls;
+    [FieldOffset(8)]
+    public TurnData TurnStats;
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 89;
+        hash = hash * 31 + Ref.GetHashCode();
+        hash = hash * 31 + StripedBalls.GetHashCode();
+        hash = hash * 31 + TurnStats.GetHashCode();
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (BallPoolPlayer*)ptr;
+        PlayerRef.Serialize(&p->Ref, serializer);
+        QBoolean.Serialize(&p->StripedBalls, serializer);
+        Quantum.TurnData.Serialize(&p->TurnStats, serializer);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct Input {
+    public const Int32 SIZE = 48;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(8)]
+    public FPVector2 BallPosition;
+    [FieldOffset(24)]
+    public FPVector3 Direction;
+    [FieldOffset(0)]
+    public FP ForceBarMarkPos;
+    public const int MAX_COUNT = 2;
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 97;
+        hash = hash * 31 + BallPosition.GetHashCode();
+        hash = hash * 31 + Direction.GetHashCode();
+        hash = hash * 31 + ForceBarMarkPos.GetHashCode();
+        return hash;
+      }
+    }
+    public static Input Read(FrameSerializer serializer) {
+      Input i = new Input();
+      Serialize(&i, serializer);
+      return i;
+    }
+    public static void Write(FrameSerializer serializer, Input i) {
+      Serialize(&i, serializer);
+    }
+    public Boolean IsDown(InputButtons button) {
+      switch (button) {
+      }
+      return false;
+    }
+    public Boolean WasPressed(InputButtons button) {
+      switch (button) {
+      }
+      return false;
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (Input*)ptr;
+        FP.Serialize(&p->ForceBarMarkPos, serializer);
+        FPVector2.Serialize(&p->BallPosition, serializer);
+        FPVector3.Serialize(&p->Direction, serializer);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct TurnData {
+    public const Int32 SIZE = 40;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(24)]
+    public AssetRefTurnConfig ConfigRef;
+    [FieldOffset(32)]
+    public EntityRef Entity;
+    [FieldOffset(0)]
+    public Int32 Number;
+    [FieldOffset(8)]
+    public PlayerRef Player;
+    [FieldOffset(12)]
+    public TurnStatus Status;
+    [FieldOffset(4)]
+    public Int32 Ticks;
+    [FieldOffset(16)]
+    public TurnType Type;
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 101;
+        hash = hash * 31 + ConfigRef.GetHashCode();
+        hash = hash * 31 + Entity.GetHashCode();
+        hash = hash * 31 + Number.GetHashCode();
+        hash = hash * 31 + Player.GetHashCode();
+        hash = hash * 31 + (Int32)Status;
+        hash = hash * 31 + Ticks.GetHashCode();
+        hash = hash * 31 + (Int32)Type;
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (TurnData*)ptr;
+        serializer.Stream.Serialize(&p->Number);
+        serializer.Stream.Serialize(&p->Ticks);
+        PlayerRef.Serialize(&p->Player, serializer);
+        serializer.Stream.Serialize((Int32*)&p->Status);
+        serializer.Stream.Serialize((Int32*)&p->Type);
+        Quantum.AssetRefTurnConfig.Serialize(&p->ConfigRef, serializer);
+        EntityRef.Serialize(&p->Entity, serializer);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct _globals_ {
+    public const Int32 SIZE = 776;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(4)]
+    public QBoolean CapturedEighthBall;
+    [FieldOffset(120)]
+    public TurnData CurrentTurn;
+    [FieldOffset(48)]
+    public FP DeltaTime;
+    [FieldOffset(80)]
+    public FrameMetaData FrameMetaData;
+    [FieldOffset(8)]
+    public QBoolean HasFirstCaptured;
+    [FieldOffset(12)]
+    public QBoolean IsFirstTurn;
+    [FieldOffset(32)]
+    public AssetRefMap Map;
+    [FieldOffset(56)]
+    public NavMeshRegionMask NavMeshRegions;
+    [FieldOffset(480)]
+    public PhysicsSceneSettings PhysicsSettings;
+    [FieldOffset(40)]
+    public BitSet2 PlayerLastConnectionState;
+    [FieldOffset(16)]
+    public QBoolean PlayerScoreThisTurn;
+    [FieldOffset(160)]
+    [FramePrinter.FixedArrayAttribute(typeof(BallPoolPlayer), 2)]
+    private fixed Byte _Players_[96];
+    [FieldOffset(20)]
+    public QBoolean ReplaceWhiteBall;
+    [FieldOffset(64)]
+    public RNGSession RngSession;
+    [FieldOffset(352)]
+    public BitSet1024 Systems;
+    [FieldOffset(0)]
+    public Int32 TicksResolving;
+    [FieldOffset(24)]
+    public QBoolean WhiteBallFirstContact;
+    [FieldOffset(256)]
+    [FramePrinter.FixedArrayAttribute(typeof(Input), 2)]
+    private fixed Byte _input_[96];
+    public FixedArray<BallPoolPlayer> Players {
+      get {
+        fixed (byte* p = _Players_) { return new FixedArray<BallPoolPlayer>(p, 48, 2); }
+      }
+    }
+    public FixedArray<Input> input {
+      get {
+        fixed (byte* p = _input_) { return new FixedArray<Input>(p, 48, 2); }
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 103;
+        hash = hash * 31 + CapturedEighthBall.GetHashCode();
+        hash = hash * 31 + CurrentTurn.GetHashCode();
+        hash = hash * 31 + DeltaTime.GetHashCode();
+        hash = hash * 31 + FrameMetaData.GetHashCode();
+        hash = hash * 31 + HasFirstCaptured.GetHashCode();
+        hash = hash * 31 + IsFirstTurn.GetHashCode();
+        hash = hash * 31 + Map.GetHashCode();
+        hash = hash * 31 + NavMeshRegions.GetHashCode();
+        hash = hash * 31 + PhysicsSettings.GetHashCode();
+        hash = hash * 31 + PlayerLastConnectionState.GetHashCode();
+        hash = hash * 31 + PlayerScoreThisTurn.GetHashCode();
+        hash = hash * 31 + HashCodeUtils.GetArrayHashCode(Players);
+        hash = hash * 31 + ReplaceWhiteBall.GetHashCode();
+        hash = hash * 31 + RngSession.GetHashCode();
+        hash = hash * 31 + Systems.GetHashCode();
+        hash = hash * 31 + TicksResolving.GetHashCode();
+        hash = hash * 31 + WhiteBallFirstContact.GetHashCode();
+        hash = hash * 31 + HashCodeUtils.GetArrayHashCode(input);
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (_globals_*)ptr;
+        serializer.Stream.Serialize(&p->TicksResolving);
+        QBoolean.Serialize(&p->CapturedEighthBall, serializer);
+        QBoolean.Serialize(&p->HasFirstCaptured, serializer);
+        QBoolean.Serialize(&p->IsFirstTurn, serializer);
+        QBoolean.Serialize(&p->PlayerScoreThisTurn, serializer);
+        QBoolean.Serialize(&p->ReplaceWhiteBall, serializer);
+        QBoolean.Serialize(&p->WhiteBallFirstContact, serializer);
+        AssetRefMap.Serialize(&p->Map, serializer);
+        Quantum.BitSet2.Serialize(&p->PlayerLastConnectionState, serializer);
+        FP.Serialize(&p->DeltaTime, serializer);
+        NavMeshRegionMask.Serialize(&p->NavMeshRegions, serializer);
+        RNGSession.Serialize(&p->RngSession, serializer);
+        FrameMetaData.Serialize(&p->FrameMetaData, serializer);
+        Quantum.TurnData.Serialize(&p->CurrentTurn, serializer);
+        FixedArray.Serialize(p->Players, serializer, StaticDelegates.SerializeBallPoolPlayer);
+        FixedArray.Serialize(p->input, serializer, StaticDelegates.SerializeInput);
+        Quantum.BitSet1024.Serialize(&p->Systems, serializer);
+        PhysicsSceneSettings.Serialize(&p->PhysicsSettings, serializer);
+    }
+  }
+  [StructLayout(LayoutKind.Explicit)]
+  public unsafe partial struct BallFields : Quantum.IComponent {
+    public const Int32 SIZE = 40;
+    public const Int32 ALIGNMENT = 8;
+    [FieldOffset(4)]
+    public QBoolean InTable;
+    [FieldOffset(0)]
+    public Int32 Number;
+    [FieldOffset(16)]
+    public AssetRefBallPoolSpec Spec;
+    [FieldOffset(24)]
+    public FPVector2 Spin;
+    [FieldOffset(8)]
+    public QBoolean Striped;
+    public override Int32 GetHashCode() {
+      unchecked { 
+        var hash = 107;
+        hash = hash * 31 + InTable.GetHashCode();
+        hash = hash * 31 + Number.GetHashCode();
+        hash = hash * 31 + Spec.GetHashCode();
+        hash = hash * 31 + Spin.GetHashCode();
+        hash = hash * 31 + Striped.GetHashCode();
+        return hash;
+      }
+    }
+    public static void Serialize(void* ptr, FrameSerializer serializer) {
+        var p = (BallFields*)ptr;
+        serializer.Stream.Serialize(&p->Number);
+        QBoolean.Serialize(&p->InTable, serializer);
+        QBoolean.Serialize(&p->Striped, serializer);
+        Quantum.AssetRefBallPoolSpec.Serialize(&p->Spec, serializer);
+        FPVector2.Serialize(&p->Spin, serializer);
+    }
+  }
+  public unsafe partial class Frame {
+    private ISignalOnBallPoolShot[] _ISignalOnBallPoolShotSystems;
+    private ISignalOnBallPoolHitHole[] _ISignalOnBallPoolHitHoleSystems;
+    private ISignalOnTurnEnded[] _ISignalOnTurnEndedSystems;
+    private ISignalOnPlayCommandReceived[] _ISignalOnPlayCommandReceivedSystems;
+    private ISignalOnSkipCommandReceived[] _ISignalOnSkipCommandReceivedSystems;
+    partial void AllocGen() {
+      _globals = (_globals_*)Context.Allocator.AllocAndClear(sizeof(_globals_));
+    }
+    partial void FreeGen() {
+      Context.Allocator.Free(_globals);
+    }
+    partial void CopyFromGen(Frame frame) {
+      Native.Utils.Copy(_globals, frame._globals, sizeof(_globals_));
+    }
+    static partial void InitStaticGen() {
+      ComponentTypeId.Setup(() => {
+        ComponentTypeId.Add<Quantum.BallFields>(Quantum.BallFields.Serialize, null, null, ComponentFlags.None);
+      });
+    }
+    partial void InitGen() {
+      Initialize(this, this.SimulationConfig.Entities);
+      _ISignalOnBallPoolShotSystems = BuildSignalsArray<ISignalOnBallPoolShot>();
+      _ISignalOnBallPoolHitHoleSystems = BuildSignalsArray<ISignalOnBallPoolHitHole>();
+      _ISignalOnTurnEndedSystems = BuildSignalsArray<ISignalOnTurnEnded>();
+      _ISignalOnPlayCommandReceivedSystems = BuildSignalsArray<ISignalOnPlayCommandReceived>();
+      _ISignalOnSkipCommandReceivedSystems = BuildSignalsArray<ISignalOnSkipCommandReceived>();
+      _ComponentSignalsOnAdded = new ComponentReactiveCallbackInvoker[ComponentTypeId.Type.Length];
+      _ComponentSignalsOnRemoved = new ComponentReactiveCallbackInvoker[ComponentTypeId.Type.Length];
+      BuildSignalsArrayOnComponentAdded<Quantum.BallFields>();
+      BuildSignalsArrayOnComponentRemoved<Quantum.BallFields>();
+      BuildSignalsArrayOnComponentAdded<CharacterController2D>();
+      BuildSignalsArrayOnComponentRemoved<CharacterController2D>();
+      BuildSignalsArrayOnComponentAdded<CharacterController3D>();
+      BuildSignalsArrayOnComponentRemoved<CharacterController3D>();
+      BuildSignalsArrayOnComponentAdded<MapEntityLink>();
+      BuildSignalsArrayOnComponentRemoved<MapEntityLink>();
+      BuildSignalsArrayOnComponentAdded<NavMeshAvoidanceAgent>();
+      BuildSignalsArrayOnComponentRemoved<NavMeshAvoidanceAgent>();
+      BuildSignalsArrayOnComponentAdded<NavMeshAvoidanceObstacle>();
+      BuildSignalsArrayOnComponentRemoved<NavMeshAvoidanceObstacle>();
+      BuildSignalsArrayOnComponentAdded<NavMeshPathfinder>();
+      BuildSignalsArrayOnComponentRemoved<NavMeshPathfinder>();
+      BuildSignalsArrayOnComponentAdded<NavMeshSteeringAgent>();
+      BuildSignalsArrayOnComponentRemoved<NavMeshSteeringAgent>();
+      BuildSignalsArrayOnComponentAdded<PhysicsBody2D>();
+      BuildSignalsArrayOnComponentRemoved<PhysicsBody2D>();
+      BuildSignalsArrayOnComponentAdded<PhysicsBody3D>();
+      BuildSignalsArrayOnComponentRemoved<PhysicsBody3D>();
+      BuildSignalsArrayOnComponentAdded<PhysicsCollider2D>();
+      BuildSignalsArrayOnComponentRemoved<PhysicsCollider2D>();
+      BuildSignalsArrayOnComponentAdded<PhysicsCollider3D>();
+      BuildSignalsArrayOnComponentRemoved<PhysicsCollider3D>();
+      BuildSignalsArrayOnComponentAdded<Transform2D>();
+      BuildSignalsArrayOnComponentRemoved<Transform2D>();
+      BuildSignalsArrayOnComponentAdded<Transform2DVertical>();
+      BuildSignalsArrayOnComponentRemoved<Transform2DVertical>();
+      BuildSignalsArrayOnComponentAdded<Transform3D>();
+      BuildSignalsArrayOnComponentRemoved<Transform3D>();
+      BuildSignalsArrayOnComponentAdded<View>();
+      BuildSignalsArrayOnComponentRemoved<View>();
+    }
+    public void SetPlayerInput(Int32 player, Input input) {
+      if ((uint)player >= (uint)_globals->input.Length) { throw new System.ArgumentOutOfRangeException("player"); }
+      var i = _globals->input.GetPointer(player);
+      i->Direction = input.Direction;
+      i->ForceBarMarkPos = input.ForceBarMarkPos;
+      i->BallPosition = input.BallPosition;
+    }
+    public Input* GetPlayerInput(Int32 player) {
+      if ((uint)player >= (uint)_globals->input.Length) { throw new System.ArgumentOutOfRangeException("player"); }
+      return _globals->input.GetPointer(player);
+    }
+    public unsafe partial struct FrameSignals {
+      public void OnBallPoolShot(PlayerRef player) {
+        var array = _f._ISignalOnBallPoolShotSystems;
+        for (Int32 i = 0; i < array.Length; ++i) {
+          var s = array[i];
+          if (_f.SystemIsEnabledInHierarchy((SystemBase)s)) {
+            s.OnBallPoolShot(_f, player);
+          }
+        }
+      }
+      public void OnBallPoolHitHole(EntityRef ball) {
+        var array = _f._ISignalOnBallPoolHitHoleSystems;
+        for (Int32 i = 0; i < array.Length; ++i) {
+          var s = array[i];
+          if (_f.SystemIsEnabledInHierarchy((SystemBase)s)) {
+            s.OnBallPoolHitHole(_f, ball);
+          }
+        }
+      }
+      public void OnTurnEnded(TurnData data, TurnEndReason reason) {
+        var array = _f._ISignalOnTurnEndedSystems;
+        for (Int32 i = 0; i < array.Length; ++i) {
+          var s = array[i];
+          if (_f.SystemIsEnabledInHierarchy((SystemBase)s)) {
+            s.OnTurnEnded(_f, data, reason);
+          }
+        }
+      }
+      public void OnPlayCommandReceived(PlayerRef player, PlayCommandData data) {
+        var array = _f._ISignalOnPlayCommandReceivedSystems;
+        for (Int32 i = 0; i < array.Length; ++i) {
+          var s = array[i];
+          if (_f.SystemIsEnabledInHierarchy((SystemBase)s)) {
+            s.OnPlayCommandReceived(_f, player, data);
+          }
+        }
+      }
+      public void OnSkipCommandReceived(PlayerRef player, SkipCommandData data) {
+        var array = _f._ISignalOnSkipCommandReceivedSystems;
+        for (Int32 i = 0; i < array.Length; ++i) {
+          var s = array[i];
+          if (_f.SystemIsEnabledInHierarchy((SystemBase)s)) {
+            s.OnSkipCommandReceived(_f, player, data);
+          }
+        }
+      }
+    }
+    public unsafe partial struct FrameEvents {
+      public const Int32 EVENT_TYPE_COUNT = 18;
+      public static Int32 GetParentEventID(Int32 eventID) {
+        switch (eventID) {
+          case EventTurnTypeChanged.ID: return EventTurnEvent.ID;
+          case EventTurnStatusChanged.ID: return EventTurnEvent.ID;
+          case EventTurnEnded.ID: return EventTurnEvent.ID;
+          case EventTurnTimerReset.ID: return EventTurnEvent.ID;
+          case EventTurnActivated.ID: return EventTurnEvent.ID;
+          case EventPlayCommandReceived.ID: return EventCommandEvent.ID;
+          case EventSkipCommandReceived.ID: return EventCommandEvent.ID;
+          default: return -1;
+        }
+      }
+      public static System.Type GetEventType(Int32 eventID) {
+        switch (eventID) {
+          case EventMessage.ID: return typeof(EventMessage);
+          case EventRemoveBall.ID: return typeof(EventRemoveBall);
+          case EventEndGame.ID: return typeof(EventEndGame);
+          case EventReplaceBall.ID: return typeof(EventReplaceBall);
+          case EventCueHitBall.ID: return typeof(EventCueHitBall);
+          case EventBallsCollision.ID: return typeof(EventBallsCollision);
+          case EventBallsHitWall.ID: return typeof(EventBallsHitWall);
+          case EventBallsHitHole.ID: return typeof(EventBallsHitHole);
+          case EventGameplayEnded.ID: return typeof(EventGameplayEnded);
+          case EventTurnEvent.ID: return typeof(EventTurnEvent);
+          case EventTurnTypeChanged.ID: return typeof(EventTurnTypeChanged);
+          case EventTurnStatusChanged.ID: return typeof(EventTurnStatusChanged);
+          case EventTurnEnded.ID: return typeof(EventTurnEnded);
+          case EventTurnTimerReset.ID: return typeof(EventTurnTimerReset);
+          case EventTurnActivated.ID: return typeof(EventTurnActivated);
+          case EventCommandEvent.ID: return typeof(EventCommandEvent);
+          case EventPlayCommandReceived.ID: return typeof(EventPlayCommandReceived);
+          case EventSkipCommandReceived.ID: return typeof(EventSkipCommandReceived);
+          default: throw new System.ArgumentOutOfRangeException("eventID");
+        }
+      }
+      public EventMessage Message(String Header, String Text) {
+        var ev = _f.Context.AcquireEvent<EventMessage>(EventMessage.ID);
+        ev.Header = Header;
+        ev.Text = Text;
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventRemoveBall RemoveBall(Int32 Num) {
+        var ev = _f.Context.AcquireEvent<EventRemoveBall>(EventRemoveBall.ID);
+        ev.Num = Num;
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventEndGame EndGame(PlayerRef Winner) {
+        var ev = _f.Context.AcquireEvent<EventEndGame>(EventEndGame.ID);
+        ev.Winner = Winner;
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventReplaceBall ReplaceBall() {
+        var ev = _f.Context.AcquireEvent<EventReplaceBall>(EventReplaceBall.ID);
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventCueHitBall CueHitBall() {
+        var ev = _f.Context.AcquireEvent<EventCueHitBall>(EventCueHitBall.ID);
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventBallsCollision BallsCollision() {
+        var ev = _f.Context.AcquireEvent<EventBallsCollision>(EventBallsCollision.ID);
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventBallsHitWall BallsHitWall() {
+        var ev = _f.Context.AcquireEvent<EventBallsHitWall>(EventBallsHitWall.ID);
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventBallsHitHole BallsHitHole() {
+        var ev = _f.Context.AcquireEvent<EventBallsHitHole>(EventBallsHitHole.ID);
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventGameplayEnded GameplayEnded() {
+        if (_f.IsPredicted) return null;
+        var ev = _f.Context.AcquireEvent<EventGameplayEnded>(EventGameplayEnded.ID);
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventTurnTypeChanged TurnTypeChanged(TurnData Turn, TurnType PreviousType) {
+        if (_f.IsPredicted) return null;
+        var ev = _f.Context.AcquireEvent<EventTurnTypeChanged>(EventTurnTypeChanged.ID);
+        ev.Turn = Turn;
+        ev.PreviousType = PreviousType;
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventTurnStatusChanged TurnStatusChanged(TurnData Turn, TurnStatus PreviousStatus) {
+        if (_f.IsPredicted) return null;
+        var ev = _f.Context.AcquireEvent<EventTurnStatusChanged>(EventTurnStatusChanged.ID);
+        ev.Turn = Turn;
+        ev.PreviousStatus = PreviousStatus;
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventTurnEnded TurnEnded(TurnData Turn, TurnEndReason Reason) {
+        if (_f.IsPredicted) return null;
+        var ev = _f.Context.AcquireEvent<EventTurnEnded>(EventTurnEnded.ID);
+        ev.Turn = Turn;
+        ev.Reason = Reason;
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventTurnTimerReset TurnTimerReset(TurnData Turn) {
+        if (_f.IsPredicted) return null;
+        var ev = _f.Context.AcquireEvent<EventTurnTimerReset>(EventTurnTimerReset.ID);
+        ev.Turn = Turn;
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventTurnActivated TurnActivated(TurnData Turn) {
+        if (_f.IsPredicted) return null;
+        var ev = _f.Context.AcquireEvent<EventTurnActivated>(EventTurnActivated.ID);
+        ev.Turn = Turn;
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventPlayCommandReceived PlayCommandReceived(PlayerRef Player, PlayCommandData Data) {
+        var ev = _f.Context.AcquireEvent<EventPlayCommandReceived>(EventPlayCommandReceived.ID);
+        ev.Player = Player;
+        ev.Data = Data;
+        _f.AddEvent(ev);
+        return ev;
+      }
+      public EventSkipCommandReceived SkipCommandReceived(PlayerRef Player, SkipCommandData Data) {
+        var ev = _f.Context.AcquireEvent<EventSkipCommandReceived>(EventSkipCommandReceived.ID);
+        ev.Player = Player;
+        ev.Data = Data;
+        _f.AddEvent(ev);
+        return ev;
+      }
+    }
+    public unsafe partial struct FrameAssets {
+      public BallPoolSpec BallPoolSpec(AssetRefBallPoolSpec assetRef) {
+         return _f.FindAsset<BallPoolSpec>(assetRef.Id);
+      }
+      public ConfigAssets ConfigAssets(AssetRefConfigAssets assetRef) {
+         return _f.FindAsset<ConfigAssets>(assetRef.Id);
+      }
+      public GameConfig GameConfig(AssetRefGameConfig assetRef) {
+         return _f.FindAsset<GameConfig>(assetRef.Id);
+      }
+      public UserMap UserMap(AssetRefUserMap assetRef) {
+         return _f.FindAsset<UserMap>(assetRef.Id);
+      }
+      public TurnConfig TurnConfig(AssetRefTurnConfig assetRef) {
+         return _f.FindAsset<TurnConfig>(assetRef.Id);
+      }
+    }
+  }
+  public unsafe interface ISignalOnBallPoolShot : ISignal {
+    void OnBallPoolShot(Frame f, PlayerRef player);
+  }
+  public unsafe interface ISignalOnBallPoolHitHole : ISignal {
+    void OnBallPoolHitHole(Frame f, EntityRef ball);
+  }
+  public unsafe interface ISignalOnTurnEnded : ISignal {
+    void OnTurnEnded(Frame f, TurnData data, TurnEndReason reason);
+  }
+  public unsafe interface ISignalOnPlayCommandReceived : ISignal {
+    void OnPlayCommandReceived(Frame f, PlayerRef player, PlayCommandData data);
+  }
+  public unsafe interface ISignalOnSkipCommandReceived : ISignal {
+    void OnSkipCommandReceived(Frame f, PlayerRef player, SkipCommandData data);
+  }
+  public unsafe partial class EventMessage : EventBase {
+    public new const Int32 ID = 0;
+    public String Header;
+    public String Text;
+    protected EventMessage(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventMessage() : 
+        base(0, EventFlags.Server|EventFlags.Client) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 37;
+        hash = hash * 31 + Header.GetHashCode();
+        hash = hash * 31 + Text.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventRemoveBall : EventBase {
+    public new const Int32 ID = 1;
+    public Int32 Num;
+    protected EventRemoveBall(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventRemoveBall() : 
+        base(1, EventFlags.Server|EventFlags.Client) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 41;
+        hash = hash * 31 + Num.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventEndGame : EventBase {
+    public new const Int32 ID = 2;
+    public PlayerRef Winner;
+    protected EventEndGame(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventEndGame() : 
+        base(2, EventFlags.Server|EventFlags.Client) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 43;
+        hash = hash * 31 + Winner.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventReplaceBall : EventBase {
+    public new const Int32 ID = 3;
+    protected EventReplaceBall(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventReplaceBall() : 
+        base(3, EventFlags.Server|EventFlags.Client) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 47;
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventCueHitBall : EventBase {
+    public new const Int32 ID = 4;
+    protected EventCueHitBall(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventCueHitBall() : 
+        base(4, EventFlags.Server|EventFlags.Client) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 53;
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventBallsCollision : EventBase {
+    public new const Int32 ID = 5;
+    protected EventBallsCollision(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventBallsCollision() : 
+        base(5, EventFlags.Server|EventFlags.Client) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 59;
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventBallsHitWall : EventBase {
+    public new const Int32 ID = 6;
+    protected EventBallsHitWall(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventBallsHitWall() : 
+        base(6, EventFlags.Server|EventFlags.Client) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 61;
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventBallsHitHole : EventBase {
+    public new const Int32 ID = 7;
+    protected EventBallsHitHole(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventBallsHitHole() : 
+        base(7, EventFlags.Server|EventFlags.Client) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 67;
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventGameplayEnded : EventBase {
+    public new const Int32 ID = 8;
+    protected EventGameplayEnded(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventGameplayEnded() : 
+        base(8, EventFlags.Server|EventFlags.Client|EventFlags.Synced) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 71;
+        return hash;
+      }
+    }
+  }
+  public abstract unsafe partial class EventTurnEvent : EventBase {
+    public new const Int32 ID = 9;
+    public TurnData Turn;
+    protected EventTurnEvent(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 73;
+        hash = hash * 31 + Turn.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventTurnTypeChanged : EventTurnEvent {
+    public new const Int32 ID = 10;
+    public TurnType PreviousType;
+    protected EventTurnTypeChanged(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventTurnTypeChanged() : 
+        base(10, EventFlags.Server|EventFlags.Client|EventFlags.Synced) {
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 79;
+        hash = hash * 31 + Turn.GetHashCode();
+        hash = hash * 31 + PreviousType.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventTurnStatusChanged : EventTurnEvent {
+    public new const Int32 ID = 11;
+    public TurnStatus PreviousStatus;
+    protected EventTurnStatusChanged(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventTurnStatusChanged() : 
+        base(11, EventFlags.Server|EventFlags.Client|EventFlags.Synced) {
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 83;
+        hash = hash * 31 + Turn.GetHashCode();
+        hash = hash * 31 + PreviousStatus.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventTurnEnded : EventTurnEvent {
+    public new const Int32 ID = 12;
+    public TurnEndReason Reason;
+    protected EventTurnEnded(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventTurnEnded() : 
+        base(12, EventFlags.Server|EventFlags.Client|EventFlags.Synced) {
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 89;
+        hash = hash * 31 + Turn.GetHashCode();
+        hash = hash * 31 + Reason.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventTurnTimerReset : EventTurnEvent {
+    public new const Int32 ID = 13;
+    protected EventTurnTimerReset(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventTurnTimerReset() : 
+        base(13, EventFlags.Server|EventFlags.Client|EventFlags.Synced) {
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 97;
+        hash = hash * 31 + Turn.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventTurnActivated : EventTurnEvent {
+    public new const Int32 ID = 14;
+    protected EventTurnActivated(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventTurnActivated() : 
+        base(14, EventFlags.Server|EventFlags.Client|EventFlags.Synced) {
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 101;
+        hash = hash * 31 + Turn.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public abstract unsafe partial class EventCommandEvent : EventBase {
+    public new const Int32 ID = 15;
+    public PlayerRef Player;
+    protected EventCommandEvent(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public new QuantumGame Game {
+      get {
+        return (QuantumGame)base.Game;
+      }
+      set {
+        base.Game = value;
+      }
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 103;
+        hash = hash * 31 + Player.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventPlayCommandReceived : EventCommandEvent {
+    public new const Int32 ID = 16;
+    public PlayCommandData Data;
+    protected EventPlayCommandReceived(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventPlayCommandReceived() : 
+        base(16, EventFlags.Server|EventFlags.Client) {
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 107;
+        hash = hash * 31 + Player.GetHashCode();
+        hash = hash * 31 + Data.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public unsafe partial class EventSkipCommandReceived : EventCommandEvent {
+    public new const Int32 ID = 17;
+    public SkipCommandData Data;
+    protected EventSkipCommandReceived(Int32 id, EventFlags flags) : 
+        base(id, flags) {
+    }
+    public EventSkipCommandReceived() : 
+        base(17, EventFlags.Server|EventFlags.Client) {
+    }
+    public override Int32 GetHashCode() {
+      unchecked {
+        var hash = 109;
+        hash = hash * 31 + Player.GetHashCode();
+        hash = hash * 31 + Data.GetHashCode();
+        return hash;
+      }
+    }
+  }
+  public static unsafe partial class BitStreamExtensions {
+    public static void Serialize(this IBitStream stream, ref AssetRefBallPoolSpec value) {
+      stream.Serialize(ref value.Id.Value);
+    }
+    public static void Serialize(this IBitStream stream, ref AssetRefConfigAssets value) {
+      stream.Serialize(ref value.Id.Value);
+    }
+    public static void Serialize(this IBitStream stream, ref AssetRefGameConfig value) {
+      stream.Serialize(ref value.Id.Value);
+    }
+    public static void Serialize(this IBitStream stream, ref AssetRefTurnConfig value) {
+      stream.Serialize(ref value.Id.Value);
+    }
+    public static void Serialize(this IBitStream stream, ref AssetRefUserMap value) {
+      stream.Serialize(ref value.Id.Value);
+    }
+  }
+  [System.SerializableAttribute()]
+  public unsafe partial class BallPoolSpec : AssetObject {
+  }
+  [System.SerializableAttribute()]
+  public unsafe partial class ConfigAssets : AssetObject {
+  }
+  [System.SerializableAttribute()]
+  public unsafe partial class GameConfig : AssetObject {
+  }
+  [System.SerializableAttribute()]
+  public unsafe partial class UserMap : AssetObject {
+  }
+  [System.SerializableAttribute()]
+  public unsafe partial class TurnConfig : AssetObject {
+  }
+  public unsafe partial class ComponentPrototypeVisitor : Prototypes.ComponentPrototypeVisitorBase {
+    public virtual void Visit(Prototypes.BallFields_Prototype prototype) {
+      VisitFallback(prototype);
+    }
+  }
+  public static unsafe partial class Constants {
+    public const Int32 MAX_PLAYERS = 2;
+  }
+  public static unsafe partial class StaticDelegates {
+    public static FrameSerializer.Delegate SerializeBallPoolPlayer;
+    public static FrameSerializer.Delegate SerializeInput;
+    static partial void InitGen() {
+      SerializeBallPoolPlayer = Quantum.BallPoolPlayer.Serialize;
+      SerializeInput = Quantum.Input.Serialize;
+    }
+  }
+  public unsafe partial class TypeRegistry {
+    partial void AddGenerated() {
+      Register(typeof(AssetGuid), AssetGuid.SIZE);
+      Register(typeof(Quantum.AssetRefBallPoolSpec), Quantum.AssetRefBallPoolSpec.SIZE);
+      Register(typeof(AssetRefCharacterController2DConfig), AssetRefCharacterController2DConfig.SIZE);
+      Register(typeof(AssetRefCharacterController3DConfig), AssetRefCharacterController3DConfig.SIZE);
+      Register(typeof(Quantum.AssetRefConfigAssets), Quantum.AssetRefConfigAssets.SIZE);
+      Register(typeof(AssetRefEntityPrototype), AssetRefEntityPrototype.SIZE);
+      Register(typeof(AssetRefEntityView), AssetRefEntityView.SIZE);
+      Register(typeof(Quantum.AssetRefGameConfig), Quantum.AssetRefGameConfig.SIZE);
+      Register(typeof(AssetRefMap), AssetRefMap.SIZE);
+      Register(typeof(AssetRefNavMesh), AssetRefNavMesh.SIZE);
+      Register(typeof(AssetRefNavMeshAgentConfig), AssetRefNavMeshAgentConfig.SIZE);
+      Register(typeof(AssetRefPhysicsMaterial), AssetRefPhysicsMaterial.SIZE);
+      Register(typeof(AssetRefPolygonCollider), AssetRefPolygonCollider.SIZE);
+      Register(typeof(AssetRefTerrainCollider), AssetRefTerrainCollider.SIZE);
+      Register(typeof(Quantum.AssetRefTurnConfig), Quantum.AssetRefTurnConfig.SIZE);
+      Register(typeof(Quantum.AssetRefUserMap), Quantum.AssetRefUserMap.SIZE);
+      Register(typeof(Quantum.BallFields), Quantum.BallFields.SIZE);
+      Register(typeof(Quantum.BallPoolPlayer), Quantum.BallPoolPlayer.SIZE);
+      Register(typeof(Quantum.BitSet1024), Quantum.BitSet1024.SIZE);
+      Register(typeof(Quantum.BitSet128), Quantum.BitSet128.SIZE);
+      Register(typeof(Quantum.BitSet2), Quantum.BitSet2.SIZE);
+      Register(typeof(Quantum.BitSet2048), Quantum.BitSet2048.SIZE);
+      Register(typeof(Quantum.BitSet256), Quantum.BitSet256.SIZE);
+      Register(typeof(Quantum.BitSet4096), Quantum.BitSet4096.SIZE);
+      Register(typeof(Quantum.BitSet512), Quantum.BitSet512.SIZE);
+      Register(typeof(Button), Button.SIZE);
+      Register(typeof(CharacterController2D), CharacterController2D.SIZE);
+      Register(typeof(CharacterController3D), CharacterController3D.SIZE);
+      Register(typeof(ColorRGBA), ColorRGBA.SIZE);
+      Register(typeof(ComponentPrototypeRef), ComponentPrototypeRef.SIZE);
+      Register(typeof(DistanceJoint), DistanceJoint.SIZE);
+      Register(typeof(DistanceJoint3D), DistanceJoint3D.SIZE);
+      Register(typeof(EntityPrototypeRef), EntityPrototypeRef.SIZE);
+      Register(typeof(EntityRef), EntityRef.SIZE);
+      Register(typeof(FP), FP.SIZE);
+      Register(typeof(FPBounds2), FPBounds2.SIZE);
+      Register(typeof(FPBounds3), FPBounds3.SIZE);
+      Register(typeof(FPMatrix2x2), FPMatrix2x2.SIZE);
+      Register(typeof(FPMatrix3x3), FPMatrix3x3.SIZE);
+      Register(typeof(FPMatrix4x4), FPMatrix4x4.SIZE);
+      Register(typeof(FPQuaternion), FPQuaternion.SIZE);
+      Register(typeof(FPVector2), FPVector2.SIZE);
+      Register(typeof(FPVector3), FPVector3.SIZE);
+      Register(typeof(FrameMetaData), FrameMetaData.SIZE);
+      Register(typeof(HingeJoint), HingeJoint.SIZE);
+      Register(typeof(HingeJoint3D), HingeJoint3D.SIZE);
+      Register(typeof(Hit), Hit.SIZE);
+      Register(typeof(Hit3D), Hit3D.SIZE);
+      Register(typeof(Quantum.Input), Quantum.Input.SIZE);
+      Register(typeof(Quantum.InputButtons), 4);
+      Register(typeof(Joint), Joint.SIZE);
+      Register(typeof(Joint3D), Joint3D.SIZE);
+      Register(typeof(LayerMask), LayerMask.SIZE);
+      Register(typeof(MapEntityId), MapEntityId.SIZE);
+      Register(typeof(MapEntityLink), MapEntityLink.SIZE);
+      Register(typeof(NavMeshAvoidanceAgent), NavMeshAvoidanceAgent.SIZE);
+      Register(typeof(NavMeshAvoidanceObstacle), NavMeshAvoidanceObstacle.SIZE);
+      Register(typeof(NavMeshPathfinder), NavMeshPathfinder.SIZE);
+      Register(typeof(NavMeshRegionMask), NavMeshRegionMask.SIZE);
+      Register(typeof(NavMeshSteeringAgent), NavMeshSteeringAgent.SIZE);
+      Register(typeof(NullableFP), NullableFP.SIZE);
+      Register(typeof(NullableFPVector2), NullableFPVector2.SIZE);
+      Register(typeof(NullableFPVector3), NullableFPVector3.SIZE);
+      Register(typeof(NullableNonNegativeFP), NullableNonNegativeFP.SIZE);
+      Register(typeof(PhysicsBody2D), PhysicsBody2D.SIZE);
+      Register(typeof(PhysicsBody3D), PhysicsBody3D.SIZE);
+      Register(typeof(PhysicsCollider2D), PhysicsCollider2D.SIZE);
+      Register(typeof(PhysicsCollider3D), PhysicsCollider3D.SIZE);
+      Register(typeof(PhysicsSceneSettings), PhysicsSceneSettings.SIZE);
+      Register(typeof(PlayerRef), PlayerRef.SIZE);
+      Register(typeof(Ptr), Ptr.SIZE);
+      Register(typeof(QBoolean), QBoolean.SIZE);
+      Register(typeof(Quantum.Ptr), Quantum.Ptr.SIZE);
+      Register(typeof(RNGSession), RNGSession.SIZE);
+      Register(typeof(Shape2D), Shape2D.SIZE);
+      Register(typeof(Shape3D), Shape3D.SIZE);
+      Register(typeof(SpringJoint), SpringJoint.SIZE);
+      Register(typeof(SpringJoint3D), SpringJoint3D.SIZE);
+      Register(typeof(Transform2D), Transform2D.SIZE);
+      Register(typeof(Transform2DVertical), Transform2DVertical.SIZE);
+      Register(typeof(Transform3D), Transform3D.SIZE);
+      Register(typeof(Quantum.TurnData), Quantum.TurnData.SIZE);
+      Register(typeof(Quantum.TurnEndReason), 4);
+      Register(typeof(Quantum.TurnStatus), 4);
+      Register(typeof(Quantum.TurnType), 4);
+      Register(typeof(View), View.SIZE);
+      Register(typeof(Quantum._globals_), Quantum._globals_.SIZE);
+    }
+  }
+  public unsafe partial class FramePrinterGen {
+    public static void EnsureNotStripped() {
+      FramePrinter.EnsurePrimitiveNotStripped<Quantum.AssetRefBallPoolSpec>();
+      FramePrinter.EnsurePrimitiveNotStripped<Quantum.AssetRefConfigAssets>();
+      FramePrinter.EnsurePrimitiveNotStripped<Quantum.AssetRefGameConfig>();
+      FramePrinter.EnsurePrimitiveNotStripped<Quantum.AssetRefTurnConfig>();
+      FramePrinter.EnsurePrimitiveNotStripped<Quantum.AssetRefUserMap>();
+      FramePrinter.EnsurePrimitiveNotStripped<Quantum.InputButtons>();
+      FramePrinter.EnsurePrimitiveNotStripped<Quantum.TurnEndReason>();
+      FramePrinter.EnsurePrimitiveNotStripped<Quantum.TurnStatus>();
+      FramePrinter.EnsurePrimitiveNotStripped<Quantum.TurnType>();
+    }
+  }
+}
+namespace Quantum.Prototypes {
+  using System;
+  using System.Collections.Generic;
+  using System.Runtime.InteropServices;
+  using Photon.Deterministic;
+  using Quantum.Core;
+  using Quantum.Collections;
+  using Quantum.Inspector;
+  using Quantum.Physics2D;
+  using Quantum.Physics3D;
+  using Optional = Quantum.Inspector.OptionalAttribute;
+  using MethodImplAttribute = System.Runtime.CompilerServices.MethodImplAttribute;
+  using MethodImplOptions = System.Runtime.CompilerServices.MethodImplOptions;
+  
+  [System.SerializableAttribute()]
+  [Prototype(typeof(TurnEndReason))]
+  public unsafe partial struct TurnEndReason_Prototype {
+    public Int32 Value;
+    public static implicit operator TurnEndReason(TurnEndReason_Prototype value) {
+        return (TurnEndReason)value.Value;
+    }
+    public static implicit operator TurnEndReason_Prototype(TurnEndReason value) {
+        return new TurnEndReason_Prototype() { Value = (Int32)value };
+    }
+  }
+  [System.SerializableAttribute()]
+  [Prototype(typeof(TurnStatus))]
+  public unsafe partial struct TurnStatus_Prototype {
+    public Int32 Value;
+    public static implicit operator TurnStatus(TurnStatus_Prototype value) {
+        return (TurnStatus)value.Value;
+    }
+    public static implicit operator TurnStatus_Prototype(TurnStatus value) {
+        return new TurnStatus_Prototype() { Value = (Int32)value };
+    }
+  }
+  [System.SerializableAttribute()]
+  [Prototype(typeof(TurnType))]
+  public unsafe partial struct TurnType_Prototype {
+    public Int32 Value;
+    public static implicit operator TurnType(TurnType_Prototype value) {
+        return (TurnType)value.Value;
+    }
+    public static implicit operator TurnType_Prototype(TurnType value) {
+        return new TurnType_Prototype() { Value = (Int32)value };
+    }
+  }
+  [System.SerializableAttribute()]
+  [Prototype(typeof(InputButtons))]
+  public unsafe partial struct InputButtons_Prototype {
+    public Int32 Value;
+    public static implicit operator InputButtons(InputButtons_Prototype value) {
+        return (InputButtons)value.Value;
+    }
+    public static implicit operator InputButtons_Prototype(InputButtons value) {
+        return new InputButtons_Prototype() { Value = (Int32)value };
+    }
+  }
+  [System.SerializableAttribute()]
+  [Prototype(typeof(BallFields))]
+  public sealed unsafe partial class BallFields_Prototype : ComponentPrototype<BallFields> {
+    public FPVector2 Spin;
+    public Int32 Number;
+    public QBoolean Striped;
+    public AssetRefBallPoolSpec Spec;
+    public QBoolean InTable;
+    partial void MaterializeUser(Frame frame, ref BallFields result, in PrototypeMaterializationContext context);
+    public override Boolean AddToEntity(FrameBase f, EntityRef entity, in PrototypeMaterializationContext context) {
+      BallFields component = default;
+      Materialize((Frame)f, ref component, in context);
+      return f.Set(entity, component) == SetResult.ComponentAdded;
+    }
+    public void Materialize(Frame frame, ref BallFields result, in PrototypeMaterializationContext context) {
+      result.InTable = this.InTable;
+      result.Number = this.Number;
+      result.Spec = this.Spec;
+      result.Spin = this.Spin;
+      result.Striped = this.Striped;
+      MaterializeUser(frame, ref result, in context);
+    }
+    public override void Dispatch(ComponentPrototypeVisitorBase visitor) {
+      ((ComponentPrototypeVisitor)visitor).Visit(this);
+    }
+  }
+  [System.SerializableAttribute()]
+  [Prototype(typeof(BallPoolPlayer))]
+  public sealed unsafe partial class BallPoolPlayer_Prototype : StructPrototype {
+    public PlayerRef Ref;
+    public TurnData_Prototype TurnStats;
+    public QBoolean StripedBalls;
+    partial void MaterializeUser(Frame frame, ref BallPoolPlayer result, in PrototypeMaterializationContext context);
+    public void Materialize(Frame frame, ref BallPoolPlayer result, in PrototypeMaterializationContext context) {
+      result.Ref = this.Ref;
+      result.StripedBalls = this.StripedBalls;
+      this.TurnStats.Materialize(frame, ref result.TurnStats, in context);
+      MaterializeUser(frame, ref result, in context);
+    }
+  }
+  [System.SerializableAttribute()]
+  [Prototype(typeof(Input))]
+  public sealed unsafe partial class Input_Prototype : StructPrototype {
+    public FPVector3 Direction;
+    public FP ForceBarMarkPos;
+    public FPVector2 BallPosition;
+    partial void MaterializeUser(Frame frame, ref Input result, in PrototypeMaterializationContext context);
+    public void Materialize(Frame frame, ref Input result, in PrototypeMaterializationContext context) {
+      result.BallPosition = this.BallPosition;
+      result.Direction = this.Direction;
+      result.ForceBarMarkPos = this.ForceBarMarkPos;
+      MaterializeUser(frame, ref result, in context);
+    }
+  }
+  [System.SerializableAttribute()]
+  [Prototype(typeof(TurnData))]
+  public sealed unsafe partial class TurnData_Prototype : StructPrototype {
+    public PlayerRef Player;
+    public MapEntityId Entity;
+    public AssetRefTurnConfig ConfigRef;
+    public TurnType_Prototype Type;
+    public TurnStatus_Prototype Status;
+    public Int32 Number;
+    public Int32 Ticks;
+    partial void MaterializeUser(Frame frame, ref TurnData result, in PrototypeMaterializationContext context);
+    public void Materialize(Frame frame, ref TurnData result, in PrototypeMaterializationContext context) {
+      result.ConfigRef = this.ConfigRef;
+      PrototypeValidator.FindMapEntity(this.Entity, in context, out result.Entity);
+      result.Number = this.Number;
+      result.Player = this.Player;
+      result.Status = this.Status;
+      result.Ticks = this.Ticks;
+      result.Type = this.Type;
+      MaterializeUser(frame, ref result, in context);
+    }
+  }
+  public unsafe partial class FlatEntityPrototypeContainer {
+    [ArrayLength(0, 1)]
+    public List<Prototypes.BallFields_Prototype> BallFields;
+    partial void CollectGen(List<ComponentPrototype> target) {
+      Collect(BallFields, target);
+    }
+    public unsafe partial class StoreVisitor {
+      public override void Visit(Prototypes.BallFields_Prototype prototype) {
+        Storage.Store(prototype, ref Storage.BallFields);
+      }
+    }
+  }
+}
+#pragma warning restore 0649
+#pragma warning restore 1522
+#pragma warning restore 0414
+#pragma warning restore 0219
+#pragma warning restore 0109

data/CommandSetup.Legacy.cs

@@ -0,0 +1,12 @@
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	public static class CommandSetup
+	{
+		public static DeterministicCommand[] CreateCommands(RuntimeConfig gameConfig, SimulationConfig simulationConfig)
+		{
+			return null;
+		}
+	}
+}

data/CommandSetup.User.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	public static partial class DeterministicCommandSetup
+	{
+		static partial void AddCommandFactoriesUser(ICollection<IDeterministicCommandFactory> factories, RuntimeConfig gameConfig, SimulationConfig simulationConfig)
+		{
+			factories.Add(new GameMaster_SetCharacterPosition());
+			factories.Add(new GameMaster_SpawnPrototype());
+		}
+	}
+}

data/CommandSetup.cs

@@ -0,0 +1,31 @@
+using Photon.Deterministic;
+using System;
+using System.Collections.Generic;
+
+namespace Quantum
+{
+	public static class CommandSetup
+	{
+		public static DeterministicCommand[] CreateCommands(RuntimeConfig gameConfig, SimulationConfig simulationConfig)
+		{
+			Type   baseType = typeof(DeterministicCommand);
+			Type[] allTypes = typeof(CommandSetup).Assembly.GetTypes();
+
+			List<DeterministicCommand> commands = new List<DeterministicCommand>(16);
+
+			foreach (Type type in allTypes)
+			{
+				if (type.IsSubclassOf(baseType) == true && type.IsAbstract == false)
+				{
+					DeterministicCommand command = Activator.CreateInstance(type) as DeterministicCommand;
+					if (command != null)
+					{
+						commands.Add(command);
+					}
+				}
+			}
+
+			return commands.ToArray();
+		}
+	}
+}

data/CommandSystem.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace Quantum
+{
+  public unsafe class CommandSystem : SystemMainThread
+  {
+    public override void Update(Frame f)
+    {
+      var currentTurn = f.Global->CurrentTurn;
+      if (currentTurn.Status != TurnStatus.Active)
+      {
+        return;
+      }
+
+
+      var currentPlayer = f.Global->CurrentTurn.Player;
+
+      switch (f.GetPlayerCommand(currentPlayer))
+      {
+        case PlayCommand playCommand:
+          if (currentTurn.Type != TurnType.Play)
+          {
+            return;
+          }
+          f.Signals.OnPlayCommandReceived(currentPlayer, playCommand.Data);
+          f.Events.PlayCommandReceived(currentPlayer, playCommand.Data);
+          break;
+
+        case SkipCommand skipCommand:
+          var config = f.FindAsset<TurnConfig>(currentTurn.ConfigRef.Id);
+          if (!config.IsSkippable)
+          {
+            return;
+          }
+          f.Signals.OnSkipCommandReceived(currentPlayer, skipCommand.Data);
+          f.Events.SkipCommandReceived(currentPlayer, skipCommand.Data);
+          break;
+      }
+    }
+  }
+}

data/ConfigAssets.cs

@@ -0,0 +1,8 @@
+namespace Quantum {
+  public partial class ConfigAssets {
+    public AssetRefGameConfig GameConfig;
+    public AssetRefTurnConfig StartCountdownConfig;
+    public AssetRefTurnConfig PlayTurnConfig;
+    public AssetRefTurnConfig CountdownTurnConfig;
+  }
+}

data/ConfigAssetsHelper.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Quantum
+{
+  unsafe public class ConfigAssetsHelper
+  {
+    public static TurnConfig GetTurnConfig(Frame f, TurnType type)
+    {
+      var configAssets = f.FindAsset<ConfigAssets>(f.RuntimeConfig.ConfigAssets.Id);
+      TurnConfig config = null;
+      switch (type)
+      {
+        case TurnType.Countdown:
+          config = f.FindAsset<TurnConfig>(configAssets.CountdownTurnConfig.Id);
+          break;
+        case TurnType.Play:
+          config = f.FindAsset<TurnConfig>(configAssets.PlayTurnConfig.Id);
+          break;
+        default:
+          break;
+      }
+      return config;
+    }
+
+    public static GameConfig GetGameConfig(Frame f) {
+      var configAssets = f.FindAsset<ConfigAssets>(f.RuntimeConfig.ConfigAssets.Id);
+      return f.FindAsset<GameConfig>(configAssets.GameConfig.Id);
+    }
+  }
+}

data/Configuration Files.txt

@@ -0,0 +1,191 @@
+Configuration Files
+Introduction
+Quantum Start Sequence
+Config Files
+PhotonServerSettings
+DeterministicConfig
+SimulationConfig
+Delta Time Type
+RuntimeConfig
+RuntimePlayer
+Using DSL Generated Code With RuntimePlayer And RuntimeConfig Serialization
+
+Introduction
+There are a few Quantum config files that have specific roles and purposes.
+
+These config files are placed in different folders in the Unity project. Finding them quickly is made easy with the shortcuts (unity) editor window found in "Menu/Quantum/Show Shortcuts".
+
+Most of default config instances reside as Scriptable Objects inside the "Resources" folder at the root level of the Unity project Assets, and will end up in your app build from there (see DeterministicSessionConfigAsset.Instance for example) while others (RuntimeConfig, RuntimePlayer) can be assembled during run-time.
+
+Back To Top
+ 
+
+Quantum Start Sequence
+Which config is used by whom and send when is shown in the diagram below.
+
+Config Sequence Diagram
+Config Sequence Diagram
+Back To Top
+ 
+
+Config Files
+
+PhotonServerSettings
+Assets/Resources/PhotonServerSettings.asset
+Quantum, from version 2.0, uses Photon Realtime to connect and communicate to the Photon Cloud. This config describes where the client connects to (cloud + region, local ip, ..).
+
+photon realtime introduction
+
+Also a valid AppId (referring to an active Quantum plugin) is set here.
+
+Only one instance of this config file is allowed. The loading is tightly integrated into the PhotonNetwork class. See PhotonNetwork.PhotonServerSettings.
+
+Photon Server Settings
+Photon Server Settings
+Back To Top
+ 
+
+DeterministicConfig
+Assets/Resouces/DeterministicConfig.asset
+Via the DeterministicConfig developers can parametrize internals of the deterministic simulation and plugin (the Quantum server component). Toggle Show Help Info in the inspector of this config for details of each parameter.
+
+The default way only allows one instance of this asset but as long as it is passed into QuantumRunner.StartParameters it does not matter how the file is retrieved.
+
+This config file will be synchronized between all clients of one session. Although each player starts their own simulation locally with their own version of the DeterministicConfig, the server will distribute the config file instance of the first player who joined the plugin.
+
+The data on this config is included in the checksum generation.
+
+Deterministic Config
+Deterministic Config
+Back To Top
+ 
+
+SimulationConfig
+Assets/Resources/DB/Configs/SimulationConfig.asset
+This config file holds parameters used in the ECS layer and inside core systems like physics and navigation. See the related system sections in the manual for more details of each value.
+
+The SimulationConfig is part of the Quantum DB and multiple instances of this config are supported. Add the config asset GUID to the RuntimeConfig to select which SimualtionConfig should be used.
+
+Developers can "extend" (create a partial class) the quantum_code/quantum.state/Core/SimulationConfig.cs class and add more data to it.
+
+Simulation Config
+Simulation Config
+Back To Top
+ 
+
+Delta Time Type
+You can customize how the QuantumRunner will accumulate elapsed time to update the Quantum simulation (see the QuantumRunner.DeltaTime property).
+
+The Default setting will use an internal stopwatch and is the recommended setting for production.
+EngineDeltaTime will use, for example Unity.deltaTime, to track when to trigger simulation updates. This is very handy when debugging the project using break points, because upon resuming the simulation with not fast-forward but continue from the exact time the simulation was paused. Alas, this setting can cause issues with time synchronization when initializing online matches: the time tracking can be inaccurate under load (e.g. level loading) and result in a lot of large extra time syncs request and cancelled inputs for a client when starting an online game.
+Back To Top
+ 
+
+RuntimeConfig
+In contrast to the SimulationConfig, which has only static configuration data, the RuntimeConfig holds information that can be different from game to game. By default is defines for example what map to load and the random start seed. It is assembled from scratch each time starting a game.
+
+Developers can add custom data to quantum_code/quantum.state/RuntimeConfig.User.cs (don't forget to fill out the serialization methods).
+
+Like the DeterministicConfig this "file" is distributed to every other client after the first player connected and joined the Quantum plugin.
+
+A convenient way of using this config is by creating a MonoBehaviour that stores an instance of RuntimeConfig (and RuntimePlayer) with default values and asset links (GUIDs) for example pointing to other asset files containing specific balancing data. When the player is inside a game lobby parts of the Runtime configs can be overwritten with his custom load-out before connecting and starting the game. See QuantumRunnerLocalDebug.cs or the sample below:
+
+Runtime Setup
+Runtime Setup
+using Quantum;
+using UnityEngine;
+
+public sealed class RuntimeSetup : MonoBehaviour
+{
+  public static RuntimeSetup  Instance { get; private set; }
+
+  public RuntimeConfig GameConfig { get { return _gameConfig;   } }
+  public RuntimePlayer PlayerConfig { get { return _playerConfig; } }
+
+  [SerializeField] private RuntimeConfig _gameConfig;
+  [SerializeField] private RuntimePlayer _playerConfig;
+
+  private void Awake() {
+    Instance = this;
+  }
+}
+Back To Top
+ 
+
+RuntimePlayer
+Similar to the RuntimeConfig the RuntimePlayer describes dynamic properties for one player (quantum_code/quantum.state/RuntimePlayer.User.cs).
+
+The data for a player behaves differently to the other configs, because it is send by each player individually after the actual game has been started. See the Player document in the manual for more information.
+
+Back To Top
+ 
+
+Using DSL Generated Code With RuntimePlayer And RuntimeConfig Serialization
+RuntimeConfig and RuntimePlayer require to write manual serialization code. When using DSL generated structs of component prototypes the serialization code can be simplified.
+
+Caveat: Never use objects that are actually pointers that require a frame to be resolved (e.g. Quantum collections).
+
+The following struct Foo43 and components prototype Component43 will be used in the RuntimePlayer.
+
+struct Foo43 {
+  int Integer;
+  array<Byte>[8] Bytes;
+  asset_ref<Map> MapAssetReference;
+  Bar43 Bar43;
+}
+
+struct Bar43 {
+  FPVector3 Vector3;
+}
+
+component Component43 {
+  int Integer;
+  OtherComponent43 OtherComponent;
+}
+
+component OtherComponent43 {
+  int Integer;
+  FP FP;
+}
+The partial RuntimePlayer.User implementation looks like this.
+
+partial class RuntimePlayer {
+  // A) Use a DSL generated struct on RuntimePlayer
+  public Foo43 Foo;
+
+  // B) Piggyback on a component prototype to set data
+  public Component43_Prototype Component43 = new Component43_Prototype { OtherComponent = new OtherComponent43_Prototype() };
+
+  partial void SerializeUserData(BitStream stream) {
+    // A) Because the struct is memory alined we can pin the memory and serialize it as a byte array which will work platform indenpentently.
+    unsafe {
+    fixed (Foo43* p = &Foo) {
+        stream.SerializeBuffer((byte*)p, sizeof(Foo43));
+    }
+    }
+
+    // B) Initialized the references in the field declaration with new and serialize all fields here.
+    stream.Serialize(ref Component43.Integer);
+    stream.Serialize(ref Component43.OtherComponent.Integer);
+    stream.Serialize(ref Component43.OtherComponent.FP);
+  }
+}
+Send the RuntimePlayer from the client:
+
+var runtimePlayer = new Quantum.RuntimePlayer {
+  Component43 = new Quantum.Prototypes.Component43_Prototype {
+    Integer = 1,
+    OtherComponent = new Quantum.Prototypes.OtherComponent43_Prototype { FP = 2, Integer = 3 } },
+  Foo = new Foo43 {
+    Bar43 = new Bar43 { Vector3 = FPVector3.One },
+    Integer = 4,
+   MapAssetReference = new AssetRefMap() { Id = 66 }
+  }
+};
+
+unsafe {
+  runtimePlayer.Foo.Bytes[0] = 7;
+  runtimePlayer.Foo.Bytes[1] = 6;
+}
+
+game.SendPlayerData(lp, runtimePlayer);

data/Consideration.cs

@@ -0,0 +1,164 @@
+using Photon.Deterministic;
+using System;
+using Quantum.Prototypes;
+
+namespace Quantum
+{
+	[Serializable]
+	public struct ResponseCurvePack
+	{
+		public FP MultiplyFactor;
+		public AssetRefAIFunctionFP ResponseCurveRef;
+		[NonSerialized] public ResponseCurve ResponseCurve;
+	}
+
+	public unsafe partial class Consideration
+	{
+		public string Label;
+
+		public AssetRefAIFunctionInt RankRef;
+		public AssetRefAIFunctionBool CommitmentRef;
+		public AssetRefConsideration[] NextConsiderationsRefs;
+		public AssetRefAIAction[] OnEnterActionsRefs;
+		public AssetRefAIAction[] OnUpdateActionsRefs;
+		public AssetRefAIAction[] OnExitActionsRefs;
+
+		[NonSerialized] public AIFunctionInt Rank;
+		[NonSerialized] public AIFunctionBool Commitment;
+		[NonSerialized] public Consideration[] NextConsiderations;
+		[NonSerialized] public AIAction[] OnEnterActions;
+		[NonSerialized] public AIAction[] OnUpdateActions;
+		[NonSerialized] public AIAction[] OnExitActions;
+
+		public ResponseCurvePack[] ResponseCurvePacks;
+
+		public FP BaseScore;
+
+		public UTMomentumData MomentumData;
+		public FP Cooldown;
+
+		public byte Depth;
+
+		public int GetRank(Frame frame, EntityRef entity = default)
+		{
+			if (Rank == null)
+				return 0;
+
+			return Rank.Execute(frame, entity);
+		}
+
+		public FP Score(Frame frame, EntityRef entity = default)
+		{
+			if (ResponseCurvePacks.Length == 0)
+				return 0;
+
+			FP score = 1;
+			for (int i = 0; i < ResponseCurvePacks.Length; i++)
+			{
+				score *= ResponseCurvePacks[i].ResponseCurve.Execute(frame, entity) * ResponseCurvePacks[i].MultiplyFactor;
+
+				// If we find a negative veto, the final score would be zero anyways, so we stop here
+				if (score == 0)
+				{
+					break;
+				}
+			}
+
+			score += BaseScore;
+
+			FP modificationFactor = 1 - (1 / ResponseCurvePacks.Length);
+			FP makeUpValue = (1 - score) * modificationFactor;
+			FP finalScore = score + (makeUpValue * score);
+
+			return finalScore;
+		}
+
+		public void OnEnter(Frame frame, UtilityReasoner* reasoner, EntityRef entity = default)
+		{
+			for (int i = 0; i < OnEnterActions.Length; i++)
+			{
+				OnEnterActions[i].Update(frame, entity);
+			}
+		}
+
+		public void OnExit(Frame frame, UtilityReasoner* reasoner, EntityRef entity = default)
+		{
+			for (int i = 0; i < OnExitActions.Length; i++)
+			{
+				OnExitActions[i].Update(frame, entity);
+			}
+		}
+
+		public void OnUpdate(Frame frame, UtilityReasoner* reasoner, EntityRef entity = default)
+		{
+			for (int i = 0; i < OnUpdateActions.Length; i++)
+			{
+				OnUpdateActions[i].Update(frame, entity);
+			}
+
+			if (NextConsiderationsRefs != null && NextConsiderationsRefs.Length > 0)
+			{
+				Consideration chosenConsideration = reasoner->SelectBestConsideration(frame, NextConsiderations, (byte)(Depth + 1), reasoner, entity);
+				if (chosenConsideration != default)
+				{
+					chosenConsideration.OnUpdate(frame, reasoner, entity);
+					UTManager.ConsiderationChosen?.Invoke(entity, chosenConsideration.Identifier.Guid.Value);
+				}
+			}
+		}
+
+		public override void Loaded(IResourceManager resourceManager, Native.Allocator allocator)
+		{
+			base.Loaded(resourceManager, allocator);
+
+			Rank = (AIFunctionInt)resourceManager.GetAsset(RankRef.Id);
+
+			if (ResponseCurvePacks != null)
+			{
+				for (Int32 i = 0; i < ResponseCurvePacks.Length; i++)
+				{
+					ResponseCurvePacks[i].ResponseCurve = (ResponseCurve)resourceManager.GetAsset(ResponseCurvePacks[i].ResponseCurveRef.Id);
+					ResponseCurvePacks[i].MultiplyFactor = 1;
+				}
+			}
+
+			OnEnterActions = new AIAction[OnEnterActionsRefs == null ? 0 : OnEnterActionsRefs.Length];
+			if (OnEnterActionsRefs != null)
+			{
+				for (Int32 i = 0; i < OnEnterActionsRefs.Length; i++)
+				{
+					OnEnterActions[i] = (AIAction)resourceManager.GetAsset(OnEnterActionsRefs[i].Id);
+				}
+			}
+
+			OnUpdateActions = new AIAction[OnUpdateActionsRefs == null ? 0 : OnUpdateActionsRefs.Length];
+			if (OnEnterActionsRefs != null)
+			{
+				for (Int32 i = 0; i < OnUpdateActionsRefs.Length; i++)
+				{
+					OnUpdateActions[i] = (AIAction)resourceManager.GetAsset(OnUpdateActionsRefs[i].Id);
+				}
+			}
+
+			OnExitActions = new AIAction[OnExitActionsRefs == null ? 0 : OnExitActionsRefs.Length];
+			if (OnEnterActionsRefs != null)
+			{
+				for (Int32 i = 0; i < OnExitActionsRefs.Length; i++)
+				{
+					OnExitActions[i] = (AIAction)resourceManager.GetAsset(OnExitActionsRefs[i].Id);
+				}
+			}
+
+			Commitment = (AIFunctionBool)resourceManager.GetAsset(CommitmentRef.Id);
+
+			NextConsiderations = new Consideration[NextConsiderationsRefs == null ? 0 : NextConsiderationsRefs.Length];
+			if (NextConsiderationsRefs != null)
+			{
+				for (Int32 i = 0; i < NextConsiderationsRefs.Length; i++)
+				{
+					NextConsiderations[i] = (Consideration)resourceManager.GetAsset(NextConsiderationsRefs[i].Id);
+				}
+			}
+		}
+	}
+}

data/DSL.txt

@@ -0,0 +1,502 @@
+Introduction
+Quantum requires components and other runtime game state data types to be declared with its own DSL (domain-specific-language).
+
+These definitions are written into text files with the .qtn extension. The Quantum compiler will parse them into an AST, and generate partial C# struct definitions for each type (definitions can be split across as many files if needed, the compiler will merge them accordingly).
+
+The goal of the DSL is to abstract away from the developer the complex memory alignment requirements imposed by Quantum's ECS sparse set memory model, required to support the deterministic predict/rollback approach to simulation.
+
+This code generation approach also eliminates the need to write "boiler-plate" code for type serialization (used for snapshots, game saves, killcam replays), checksumming and other functions, like printing/dumping frame data for debugging purposes.
+
+The quantum dsl integration section shows how to add qtn files to the workflow.
+
+Components
+Components are special structs that can be attached to entities, and used for filtering them (iterating only a subset of the active entities based on its attached components). This is a basic example definition of a component:
+
+component Action
+{
+    FP Cooldown;
+    FP Power;
+}
+These will be turned into regular C# structs. Labelling them as components (like above) will generate the appropriate code structure (marker interface, id property, etc).
+
+Aside from custom components, Quantum comes with several pre-built ones:
+
+Transform2D/Transform3D: position and rotation using Fixed Point (FP) values;
+PhysicsCollider, PhysicsBody, PhysicsCallbacks, PhysicsJoints (2D/3D): used by Quantum's stateless physics engines;
+PathFinderAgent, SteeringAgent, AvoidanceAgent, AvoidanceObstacle: navmesh-based path finding and movement.
+Back To Top
+ 
+
+Structs
+Structs can be defined in both the DSL and C#.
+
+
+DSL Defined
+The Quantum DSL also allows the definition of regular structs (just like components, memory alignment, and helper functions will be taken care of):
+
+struct ResourceItem
+{
+    FP Value;
+    FP MaxValue;
+    FP RegenRate;
+}
+The fields will be ordered in alphabetical order when the struct is generated. If you need / want to have them appear in a specific order, you will have to define the structs in C# (see section below).
+
+This would let you use the "Resources" struct as a type in all other parts of the DSL, for example using it inside a component definition:
+
+component Resources
+{
+    ResourceItem Health;
+    ResourceItem Strength;
+    ResourceItem Mana;
+}
+The generated struct is partial and can be extended in C# if so desired.
+
+Back To Top
+ 
+
+CSharp Defined
+You can define structs in C# as well; however, in this case you will have to manually define the memory aligned of the struct.
+
+[StructLayout(LayoutKind.Explicit)]
+public struct Foo {
+  public const int SIZE = 12; // the size in bytes of all members in bytes.
+
+  [FieldOffset(0)]
+  public int A;
+
+  [FieldOffset(4)]
+  public int B;
+
+  [FieldOffset(8)]
+  public int C;
+}
+When using C# defined structs in the DSL (e.g. inside components), you will have to manually import the struct definition.
+
+import struct Foo(12);
+N.B.: The import does not support constants in the size; you will have to specify the exact numerical value each time.
+
+Back To Top
+ 
+
+Components Vs. Structs
+An important question is why and when should components be used instead of regular structs (components, in the end, are also structs).
+
+Components contain generated meta-data that turns them into a special type with the following features:
+
+Can be attached directly to entities;
+Used to filter entities when traversing the game state (next chapter will dive into the filter API);
+Components can accessed, used or passed as parameters as either pointers or as value types, just like any other struct.
+
+Back To Top
+ 
+
+Dynamic Collections
+Quantum's custom allocator exposes blittable collections as part of the rollback-able game state. Collections only support support blittable types (i.e. primitive and DSL-defined types).
+
+To manage collection, the Frame API offers 3 methods for each:
+
+Frame.AllocateXXX: To allocate space for the collection on the heap.
+Frame.FreeXXX: To free/deallocate the collection's memory.
+Frame.ResolveXXX: To access the collection by resolving the pointer it.
+Note: After freeing a collection, it HAS TO be nullified by setting it to default. This is required for serialization of the game state to work properly. Omitting the nullification will result in indeterministic behavior and desynchronisation. As alternative to freeing a collection and nullifying its Ptrs manually, it possible to use the FreeOnComponentRemoved attribute on the field in question.
+
+Back To Top
+ 
+
+Important Notes
+Several components can reference the same collection instance.
+Dynamic collections are stored as references inside components and structs. They therefore have to to be allocated when initializing them, and more importantly, freed when they are not needed any more. If the collection is part of a component, two options are available:
+implement the reactive callbacks ISignalOnAdd<T> and ISignalOnRemove<T> and allocate/free the collections there. (For more information on these specific signals, see the Components page in the ECS section of the Manual); or,
+use the [AllocateOnComponentAdded] and [FreeOnComponentRemoved] attributes to let Quantum handle the allocation and deallocation when the component is added and removed respectively.
+Quantum do NOT pre-allocate collections from prototypes, unless there is at least value. If the collection is empty, the memory has to be manually allocated.
+Attempting to free a collection more than once will throw an error and puts the heap in an invalid state internally.
+Back To Top
+ 
+
+Lists
+Dynamic lists can be defined in the DSL using list<T> MyList.
+
+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)
+Once resolved, a list can be iterated over or manipulated with all the expected API methods of a list such as Add, Remove, Contains, IndexOf, RemoveAt, [], etc... .
+
+To use the list in the component of type Targets defined in the code snippet above, you could create the following system:
+
+namespace Quantum
+{
+    public unsafe class HandleTargets : SystemMainThread, ISignalOnComponentAdded<Targets>, ISignalOnComponentRemoved<Targets>
+    {
+        public override void Update(Frame f)
+        {
+            var targets = f.GetComponentIterator<Targets>();
+
+            for (int i = 0; i < targets.Count; i++)
+            {
+                var target = targets[i];
+
+                // To use a list, you must first resolve its pointer via the frame
+                var list = frame.ResolveList(target.Enemies);
+
+                // Do stuff
+            }
+        }
+
+        public void OnAdded(Frame f, EntityRef entity, Targets* component)
+        {
+            // allocating a new List (returns the blittable reference type - QListPtr)
+            component->Enemies = f.AllocateList<EntityRef>();
+        }
+
+        public void OnRemoved(Frame f, EntityRef entity, Targets* component)
+        {
+            // A component HAS TO de-allocate all collection it owns from the frame data, otherwise it will lead to a memory leak.
+            // receives the list QListPtr reference.
+            f.FreeList(component->Enemies);
+
+            // All dynamic collections a component points to HAVE TO be nullified in a component's OnRemoved
+            // EVEN IF is only referencing an external one!
+            // This is to prevent serialization issues that otherwise lead to a desynchronisation.
+            component->Enemies = default;
+        }
+    }
+}
+Back To Top
+ 
+
+Dictionaries
+Dictionaries can be declared in the DSL like so dictionary<key, value> MyDictionary.
+
+component Hazard{
+    dictionary<EntityRef, Int32> DamageDealt;
+}
+The basic API methods for dealing with these dictionaries are:
+
+Frame.AllocateDictionary<K,V>()
+Frame.FreeDictionary(QDictionaryPtr<K,V> ptr)
+Frame.ResolveDictionary(QDictionaryPtr<K,V> ptr)
+Just like with any other dynamic collection it is mandatory to allocate it before using it, as well as de-allocate it from the frame data and nullified it once the dictionary is no longer used. See the example provided in the section about lists here above.
+
+Back To Top
+ 
+
+HashSet
+HashSets can be declared in the DSL like so hash_set<T> MyHashSet.
+
+component Nodes{
+    hash_set<FP> ProcessedNodes;
+}
+The basic API methods for dealing with these dictionaries are:
+
+Frame.AllocateHashSet(QHashSetPtr<T> ptr, int capacity = 8)
+Frame.FreeHashSet(QHashSetPtr<T> ptr)
+Frame.ResolveHashSet(QHashSetPtr<T> ptr)
+Just like with any other dynamic collection it is mandatory to allocate it before using it, as well as de-allocate it from the frame data and nullified it once the hash set is no longer used. See the example provided in the section about lists here above.
+
+Back To Top
+ 
+
+Unions, Enums And Bitsets
+C-like unions and enums can be generated as well. The example below demonstrates how to save data memory by overlapping some mutually exclusive data types/values into a union:
+
+struct DataA
+{
+    FPVector2 Something;
+    FP Anything;
+}
+
+struct DataB
+{
+    FPVector3 SomethingElse;
+    Int32 AnythingElse;
+}
+
+union Data
+{
+    DataA A;
+    DataB B;
+}
+The generated type Data will also include a differentiator property (to tell which union-type has been populated). "Touching" any of the union sub-types will set this property to the appropriate value.
+
+Bitsets can be used to declared fixed-size memory blocks for any desired purpose (for example fog-of-war, grid-like structures for pixel perfect game mechanics, etc.):
+
+struct FOWData
+{
+    bitset[256] Map;
+}
+Back To Top
+ 
+
+Input
+In Quantum, the runtime input exchanged between clients is also declared in the DSL. This example defines a simple movement vector and a Fire button as input for a game:
+
+input
+{
+    FPVector2 Movement;
+    button Fire;
+}
+The input struct is polled every tick and sent to the server (when playing online).
+
+For more information about input, such as best practices and recommended approaches to optimization, refer to this page: input
+
+Back To Top
+ 
+
+Signals
+Signals are function signatures used as a decoupled inter-system communication API (a form of publisher/subscriber API). This would define a simple signal (notice the special type entity_ref - these will be listed at the end of this chapter):
+
+signal OnDamage(FP damage, entity_ref entity);
+This would generate the following interface (that can be implemented by any System):
+
+public interface ISignalOnDamage
+{
+    public void OnDamage(Frame f, FP damage, EntityRef entity);
+}
+Signals are the only concept which allows the direct declaration of a pointer in Quantum's DSL, so passing data by reference can be used to modify the original data directly in their concrete implementations:
+
+signal OnBeforeDamage(FP damage, Resources* resources);
+Notice this allows the passing of a component pointer (instead of the entity reference type).
+
+Back To Top
+ 
+
+Events
+Events are a fine-grained solution to communicate what happens inside the simulation to the rendering engine / view (they should never be used to modify/update part of the game state). Use the "event" keyword to define its name and data:
+
+Find detailed information about events in the game events manual.
+
+Define an event using the Quantum DSL
+
+event MyEvent{
+    int Foo;
+}
+Trigger the event from the simulation
+
+f.Events.MyEvent(2022);
+And subscribe and consume the event in Unity
+
+QuantumEvent.Subscribe(listener: this, handler: (MyEvent e) => Debug.Log($"MyEvent {e.Foo}"));
+Back To Top
+ 
+
+Globals
+It is possible to define globally accessible variables in the DSL. Globals can be declared in any .qtn file by using the global scope.
+
+global {
+    // Any type that is valid in the DSL can also be used.
+    FP MyGlobalValue;
+}
+Like all things DSL-defined, global variables are part of the state and are fully compatible with the predict-rollback system.
+
+Variables declared in the global scope are made available through the Frame API. They can be accessed (read/write) from any place that has access to the frame - see the Systems document in the ECS section.
+
+N.B.: An alternative to global variables are the Singleton Components; for more information please refer to the Components page in the ECS section of the manual.
+
+Back To Top
+ 
+
+Special Types
+Quantum has a few special types that are used to either abstract complex concepts (entity reference, player indexes, etc.), or to protect against common mistakes with unmanaged code, or both. The following special types are available to be used inside other data types (including in components, also in events, signals, etc.):
+
+player_ref: represents a runtime player index (also cast to and from Int32). When defined in a component, can be used to store which player controls the associated entity (combined with Quantum's player-index-based input).
+entity_ref: because each frame/tick data in quantum resides on a separate memory region/block (Quantum keeps a a few copies to support rollbacks), pointers cannot be cached in-between frames (nor in the game state neither in Unity scripts). An entity ref abstracts an entity's index and version properties (protecting the developer from accidentally accessing deprecated data over destroyed or reused entity slots with old refs).
+asset_ref<AssetType>: rollback-able reference to a data asset instance from the Quantum asset database (please refer to the data assets chapter).
+list<T>, dictionary<K,T>: dynamic collection references (stored in Quantum's frame heap). Only supports blittable types (primitives + DSL-defined types).
+array<Type>[size]: fixed sized "arrays" to represent data collections. A normal C# array would be a heap-allocated object reference (it has properties, etc.), which violates Quantum's memory requirements, so the special array type generates a pointer based simple API to keep rollback-able data collections inside the game state;
+Back To Top
+ 
+
+A Note On Assets
+Assets are a special feature of Quantum that let the developer define data-driven containers (normal classes, with inheritance, polymorphic methods, etc.) that end up as immutable instances inside an indexed database. The "asset" keyword is used to assign an (existing) class as a data asset that can have references assigned inside the game state (please refer to the Data Assets chapter to learn more about features and restrictions):
+
+asset CharacterData; // the CharacterData class is partially defined in a normal C# file by the developer
+The following struct show some valid examples of the types above (sometimes referencing previously defined types):
+
+struct SpecialData
+{
+    player_ref Player;
+    entity_ref Character;
+    entity_ref AnotherEntity;
+    asset_ref<CharacterData> CharacterData;
+    array<FP>[10] TenNumbers;
+}
+Back To Top
+ 
+
+Available Types
+When working in the DSL, you can use a variety of types. Some are pre-imported by the parsers, while others need to be manually imported.
+
+
+By Default
+Quantum's DSL parser has a list of pre-imported cross-platform deterministic types that can be used in the game state definition:
+
+Boolean / bool - internally gets wrapped in QBoolean which works identically (get/set, compare, etc...)
+Byte
+SByte
+UInt16 / Int16
+UInt32 / Int32
+UInt64 / Int64
+FP
+FPVector2
+FPVector3
+FPMatrix
+FPQuaternion
+PlayerRef / player_ref in the DSL
+EntityRef / entity_ref in the DSL
+LayerMask
+NullableFP / FP? in the DSL
+NullableFPVector2 / FPVector2? in the DSL
+NullableFPVector3 / FPVector3? in the DSL
+QString is for UTF-16 (aka Unicode in .NET)
+QStringUtf8 is always UTF-8
+Hit
+Hit3D
+Shape2D
+Shape3D
+Joint, DistanceJoint, SpringJoint and HingeJoint
+Note on QStrings: N represents the total size of the string in bytes minus 2 bytes used for bookkeeping. In other words QString<64> will use 64 bytes for a string with a max byte length of 62 bytes, i.e. up to 31 UTF-16 characters.
+
+Back To Top
+ 
+
+Manual Import
+If you need a type that is not listed in the previous section, you will have to import it manually when using it in QTN files.
+
+
+Namespaces / Types Outside Of Quantum
+To import types defined in other namespaces, you can use the following syntax:
+
+import MyInterface;
+or
+import MyNameSpace.Utils;
+For an enum the syntax is as follows:
+
+import enum MyEnum(underlying_type);
+
+// This syntax is identical for Quantum specific enums
+import enum Shape3DType(byte);
+Back To Top
+ 
+
+Built-In Quantum Type And Custom Type
+When importing a Quantum built-in type or a custom type, the struct size is predefined in their C# declaration. It is therefore important to add some safety measures.
+
+namespace Quantum {
+  [StructLayout(LayoutKind.Explicit)]
+  public struct Foo {
+    public const int SIZE = sizeof(Int32) * 2;
+    [FieldOffset(0)]
+    public Int32 A;
+    [FieldOffset(sizeof(Int32))]
+    public Int32 B;
+  }
+}
+#define FOO_SIZE 8 // Define a constant value with the known size of the struct
+import struct Foo(8);
+To ensure the expected size of the struct is equal to the actual size, it is recommended to add an Assert as shown below in one of your systems.
+
+public unsafe class MyStructSizeCheckingSystem : SystemMainThread{
+    public override void OnInit(Frame f)
+    {
+        Assert.Check(Constants.FOO_SIZE == Foo.SIZE);
+    }
+}
+If the size of the built-in struct changes during an upgrade, this Assert will throw and allow you to update the values in the DSL.
+
+Back To Top
+ 
+
+Attributes
+Quantum supports several attributes to present parameters in the Inspector.
+
+The attributes are contained within the Quantum.Inspector namespace.
+
+Attribute	Parameters	Description
+DrawIf	string fieldName
+long value
+CompareOperator compare
+HideType hide	Displays the property only if the condition evaluates to true.
+
+fieldName = the name of the property to evaluate.
+value = the value used for comparison.
+compare = the comparison operation to be performed Equal, NotEqual, Less, LessOrEqual, GreaterOrEqual or Greater.
+hide = the field's behavior when the expression evaluates to False:Hide or ReadOnly.
+
+For more information on compare and hide, see below.
+Header	string header	Adds a header above the property.
+
+header = the header text to display.
+HideInInspector	-	Serializes the field and hides the following property in the Unity inspector.
+Layer	-	Can only be applied to type int.
+Will call EditorGUI.LayerField on the field.
+Optional	string enabledPropertyPath	Allows to turn the display of a property on/off.
+
+enabledPropertyPath = the path to the bool used to evaluate the toggle.
+Space	-	Adds a space above the property
+Tooltip	string tooltip	Displays a tool tip when hovering over the property.
+
+tooltip = the tip to display.
+ArrayLength (since 2.1)
+FixedArray (in 2.0)
+ONLY FOR CSharp	int length
+--------
+int minLength
+int maxLength	Using length allows to define the size of a an array.
+------
+Using minLength and maxLength allows to define a range for the size in the Inspector.
+The final size can then be set in the Inspector.
+(minLength and maxLength are inclusive)
+ExcludeFromPrototype	-	Can be applied to both a component and component fields.
+------
+- Field: Excludes field from a the prototype generated for the component.
+- Component: No prototype will be generated for this component.
+PreserveInPrototype	-	Added to a type marks it as usable in prototypes and prevents prototype class from being emit.
+Added to a field only affects a specific field. Useful for simple [Serializable] structs as it avoids having to use _Prototype types on Unity side.
+AllocateOnComponentAdded	-	Can be applied to dynamic collections.
+This will allocate memory for the collection if it has not already been allocated when the component holding the collection is added to an entity.
+FreeOnComponentRemoved	-	Can be applied to dynamic collections and Ptrs.
+This will deallocate the associated memory and nullify the Ptr held in the field when the component is removed.
+------
+IMPORTANT: Do NOT use this attribute in combination with cross-referenced collections as it only nullifies the Ptr held in that particular field and the others will be pointing to invalid memory.
+The *Attributes* can be used in both C# and qtn files unless otherwise specified; however, there are some syntactic differences.
+Back To Top
+ 
+
+Use In CSharp
+In C# files, attributes can be used and concatenated like any other attribute.
+
+// Multiple single attributes
+[Header("Example Array")][Tooltip("min = 1\nmax = 20")] public FP[] TestArray = new FP[20];
+
+// Multiple concatenated attributes
+[Header("Example Array"), Tooltip("min = 1\nmax = 20")] public FP[] TestArray = new FP[20];
+Back To Top
+ 
+
+Use In Qtn
+In qtn files, the usage of single attributes remains the same as in C#.
+
+[Header("Example Array")] array<FP>[20] TestArray;
+When combining multiple attributes, they have to be concatenated.
+
+[Header("Example Array"), Tooltip("min = 1\nmax = 20")] array<FP>[20] TestArray;
+Back To Top
+ 
+
+Compiler Options
+The following compiler options are currently available to be used inside Quantum's DSL files (more will be added in the future):
+
+// pre defining max number of players (default is 6, absolute max is 64)
+#pragma max_players 16
+
+// numeric constants (useable inside the DSL by MY_NUMBER and useable in code by Constants.MY_NUMBER)
+#define MY_NUMBER 10
+
+// overriding the base class name for the generated constants (default is "Constants")
+#pragma constants_class_name MyFancyConstants

data/DeadPieceSlot.cs

@@ -0,0 +1,8 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class DeadPieceSlot : MonoBehaviour {
+
+  public PieceView Piece;
+}

data/DebugAction.cs

@@ -0,0 +1,13 @@
+namespace Quantum
+{
+	[System.Serializable]
+	public unsafe class DebugAction : AIAction
+	{
+		public string Message;
+
+		public override void Update(Frame frame, EntityRef entity)
+		{
+			Log.Info(Message);
+		}
+	}
+}

data/DebugLeaf.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace Quantum
+{
+	[Serializable]
+	public unsafe partial class DebugLeaf : BTLeaf
+	{
+
+		public string Message;
+
+		/// <summary>
+		/// When Update is called, we just write a message on the console.
+		/// This Leaf never fails, nor takes more than one frame to finish,
+		/// so we always return Success.
+		/// </summary>
+		protected override BTStatus OnUpdate(BTParams btParams)
+		{
+			Log.Info(Message + " | Frame: " + btParams.Frame.Number);
+
+			return BTStatus.Success;
+		}
+	}
+}

data/DebugService.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace Quantum
+{
+	[Serializable]
+	public unsafe partial class DebugService : BTService
+	{
+		public string Message;
+		protected unsafe override void OnUpdate(BTParams btParams)
+		{
+			Log.Info($"[BT SERVICE] { Message } | Frame: {btParams.Frame.Number}");
+		}
+	}
+}

data/EffectArea.cs

@@ -0,0 +1,81 @@
+namespace Quantum
+{
+	using Photon.Deterministic;
+
+	public unsafe partial struct EffectArea
+	{
+		public void Update(Frame frame, EntityRef entity)
+		{
+			StateTime -= frame.DeltaTime;
+
+			if (State == EEffectAreaState.Init)
+			{
+				if (StateTime <= FP._0)
+				{
+					State     = EEffectAreaState.Active;
+					TickCount = System.Math.Max((byte)1, TickCount);
+			
+					var behaviors = frame.ResolveList(Behaviors);
+
+					for (int idx = 0, count = behaviors.Count; idx < count; idx++)
+					{
+						behaviors.GetPointer(idx)->Initialize(Level);
+					}
+				}
+			}
+
+			if (State == EEffectAreaState.Active)
+			{
+				if (StateTime <= FP._0)
+				{
+					TickCount -= 1;
+					ProcessEffect(frame, entity);
+
+					StateTime = TickTime;
+				}
+
+				if (TickCount == 0)
+				{
+					State     = EEffectAreaState.Finished;
+					StateTime = FP._0_50;
+				}
+			}
+
+			if (State == EEffectAreaState.Finished)
+			{
+				if (StateTime <= FP._0)
+				{
+					frame.Destroy(entity);
+				}
+			}
+		}
+
+		private void ProcessEffect(Frame frame, EntityRef entity)
+		{
+			var position  = frame.Unsafe.GetPointer<Transform2D>(entity)->Position;
+			var behaviors = frame.ResolveList(Behaviors);
+
+			foreach (var targetPair in frame.Unsafe.GetComponentBlockIterator<Target>())
+			{
+				if (TargetType == EEffectAreaTarget.Enemy && targetPair.Component->OwnerPlayerRef == Owner)
+					continue;
+				if (TargetType == EEffectAreaTarget.Friendly && targetPair.Component->OwnerPlayerRef != Owner)
+					continue;
+
+				var targetPosition = frame.Unsafe.GetPointer<Transform2D>(targetPair.Entity)->Position;
+				var distance       = (targetPosition - position).SqrMagnitude;
+
+				var radiusSqr  = Radius + targetPair.Component->Size;
+				    radiusSqr *= radiusSqr;
+
+				if (distance > radiusSqr)
+					continue;
+
+				for (int idx = 0, count = behaviors.Count; idx < count; idx++)
+				{
+					behaviors.GetPointer(idx)->ProcessEffect(frame, entity, targetPair.Entity, Level);
+				}
+			}
+		}
+	}
+}

data/EffectArea.qtn

@@ -0,0 +1,42 @@
+component EffectArea
+{
+	[ExcludeFromPrototype] list<EffectAreaBehavior> Behaviors;
+	[ExcludeFromPrototype] PlayerRef                Owner;
+	[ExcludeFromPrototype] FP                       Radius;
+	[ExcludeFromPrototype] FP                       StateTime;
+	[ExcludeFromPrototype] EEffectAreaState         State;
+	[ExcludeFromPrototype] FP                       TickTime;
+	[ExcludeFromPrototype] byte                     TickCount;
+	[ExcludeFromPrototype] byte                     Level;
+	[ExcludeFromPrototype] EEffectAreaTarget        TargetType;
+}
+
+enum EEffectAreaState : Byte
+{
+	Init,
+	Active,
+	Finished,
+}
+
+enum EEffectAreaTarget : Byte
+{
+	Enemy,
+	Friendly,
+}
+
+union EffectAreaBehavior
+{
+	EffectAreaBehavior_Damage Damage;
+	EffectAreaBehavior_Buff   Buff;
+}
+
+struct EffectAreaBehavior_Damage
+{
+	FP Damage;
+	FP DamagePerLevelPercent;
+}
+
+struct EffectAreaBehavior_Buff
+{
+	AssetRefEntityPrototype Buff;
+}

data/EffectAreaBehavior.cs

@@ -0,0 +1,30 @@
+namespace Quantum
+{
+	public unsafe partial struct EffectAreaBehavior
+	{
+		public void Initialize(byte level)
+		{
+			switch (Field)
+			{
+				case DAMAGE: _Damage.Initialize(level); break;
+
+				case BUFF:   break;
+
+				default:
+					throw new System.NotImplementedException();
+			}
+		}
+
+		public void ProcessEffect(Frame frame, EntityRef entity, EntityRef target, byte level)
+		{
+			switch (Field)
+			{
+				case DAMAGE: _Damage.ProcessEffect(frame, entity, target);      break;
+				case BUFF:   _Buff.ProcessEffect(frame, entity, target, level); break;
+
+				default:
+					throw new System.NotImplementedException();
+			}
+		}
+	}
+}

data/EffectAreaBehavior_Buff.cs

@@ -0,0 +1,16 @@
+namespace Quantum
+{
+	public unsafe partial struct EffectAreaBehavior_Buff
+	{
+		// PUBLIC METHODS
+
+		public void ProcessEffect(Frame frame, EntityRef entity, EntityRef target, byte level)
+		{
+			if (frame.Unsafe.TryGetPointer<Buffs>(target, out var buffs) == false)
+				return;
+
+
+			buffs->AddBuff(frame, entity, target, Buff, level);
+		}
+	}
+}

data/EffectAreaBehavior_Damage.cs

@@ -0,0 +1,31 @@
+namespace Quantum
+{
+	using Photon.Deterministic;
+
+	public unsafe partial struct EffectAreaBehavior_Damage
+	{
+		public void Initialize(byte level)
+		{
+			var perLevel = FP._1 + DamagePerLevelPercent * FP._0_01;
+
+			for (int idx = 1; idx < level; idx++)
+			{
+				Damage *= perLevel;
+			}
+		}
+
+		public void ProcessEffect(Frame frame, EntityRef entity, EntityRef target)
+		{
+			var position   = frame.Unsafe.GetPointer<Transform2D>(entity)->Position;
+			var healthData = new HealthData()
+			{
+				Action = EHealthAction.Remove,
+				Value  = Damage,
+				Target = target,
+			};
+
+			var targetHealth = frame.Unsafe.GetPointer<Health>(target);
+			targetHealth->ApplyHealthData(frame, healthData);
+		}
+	}
+}

data/EffectAreaSettings.cs

@@ -0,0 +1,18 @@
+namespace Quantum
+{
+	using Quantum.Prototypes;
+	using Quantum.Inspector;
+	using Photon.Deterministic;
+
+	[System.Serializable]
+	public class EffectAreaSettings : CardSettings
+	{
+		[Header("Effect Area")]
+		public FP                             TickTime;
+		public byte                           TickCount;
+		public FP                             Radius;
+		public EEffectAreaTarget              Target;
+		[Space]
+		public EffectAreaBehavior_Prototype[] Behaviors;
+	}
+}

data/EffectAreaSystem.cs

@@ -0,0 +1,13 @@
+namespace Quantum
+{
+	unsafe class EffectAreaSystem : SystemMainThread
+	{
+		public override void Update(Frame frame)
+		{
+			foreach (var pair in frame.Unsafe.GetComponentBlockIterator<EffectArea>())
+			{
+				pair.Component->Update(frame, pair.Entity);
+			}
+		}
+	}
+}

data/Fixed Point.txt

@@ -0,0 +1,256 @@
+Introduction
+In Quantum the FP struct (Fixed Point) completely replaces all usages of floats and doubles to ensure cross-platform determinism. It offers versions of common math data structures like FPVector2, FPVector3, FPMatrix, FPQuaternion, RNGSession, FPBounds2, etc. All systems in Quantum, including physics and navigation, exclusively use FP values in their computations.
+
+The fixed-point type implemented in Quantum is Q48.16. It has proved to a good balance between precision and performance with a bias towards the latter.
+
+Internally FP uses one long to represent the combined fixed-point number (whole number + decimal part); the long value can be accessed and set via FP.RawValue.
+
+Quantum's FP Math uses carefully tuned look up tables for fast trigonometric and square root functions (see QuantumSDK\quantum_unity\Assets\Photon\Quantum\Resources\LUT).
+
+Back To Top
+ 
+
+Parsing FPs
+The representable FP fraction is limited and never as accurate as a double. Parsing is an approximation and will round to the nearest possible FP precision. This is reflected in:
+
+parsing an FP as the float 1.1f and then converting back to float possibly resulting in 1.09999999f; and,
+different parsing methods yielding different results on the same machine.
+FP.FromFloat(1.1f).RawValue != FP.FromString("1.1").RawValue
+Back To Top
+ 
+
+TLDR
+Use from float only during edit time, never inside the simulation or at runtime.
+It is best to convert from raw whenever possible.
+Back To Top
+ 
+
+FP.FromFloat_UNSAFE()
+Converting from float is not deterministic due to rounding errors and should never be done inside the simulation. Doing such a conversion in the simulation will cause desyncs 100% of the time.
+
+However, it can be used during edit or build time, when the converted (FP) data is first created and then shared with everyone. IMPORTANT: Data generated this way on different machines may not be compatible.
+
+var v = FP.FromFloat_UNSAFE(1.1f);
+Back To Top
+ 
+
+FP.FromString_UNSAFE()
+This will internally parse the string as a float and then convert to FP. All caveats from FromFloat_UNSAFE() apply here as well.
+
+var v = FP.FromFloat_UNSAFE("1.1");
+Back To Top
+ 
+
+FP.FromString()
+This is deterministic and therefore safe to use anywhere but may not be the most performant option. A typical use case is balancing information (patch) that clients load from a server and then use to update data in Quantum assets.
+
+Be aware of the string locale! It only parses English number formatting for decimals and requires a dot (e.g. 1000.01f).
+
+var v = FP.FromFloat("1.1");
+Back To Top
+ 
+
+FP.FromRaw()
+This is secure and fast as it mimics the internal representation.
+
+var v = FP.FromRaw(72089);
+This snippet can be used to create a FP converter window in Unity for convient conversion.
+
+using System;
+using UnityEditor;
+using Photon.Deterministic;
+
+public class FPConverter : EditorWindow {
+  private float _f;
+  private FP _fp;
+
+  [MenuItem("Quantum/FP Converter")]
+  public static void ShowWindow() {
+    GetWindow(typeof(FPConverter), false, "FP Converter");
+  }
+
+  public virtual void OnGUI() {
+    _f = EditorGUILayout.FloatField("Input", _f);
+    try {
+      _fp = FP.FromFloat_UNSAFE(_f);
+      var f = FPPropertyDrawer.GetRawAsFloat(_fp.RawValue);
+      var rect = EditorGUILayout.GetControlRect(true);
+      EditorGUI.FloatField(rect, "Output FP", f);
+      QuantumEditorGUI.Overlay(rect, "(FP)");
+      EditorGUILayout.LongField("Output Raw", _fp.RawValue);
+    }
+    catch (OverflowException e) {
+      EditorGUILayout.LabelField("Out of range");
+    }
+  }
+}
+Back To Top
+ 
+
+Const Variables
+The `FP._1_10` syntax can not be extended or generated.
+FP is a struct and can therefore not be used as a constant. It is, however, possible to hard-code and use "FP" values in const variables:
+
+Combine pre-defined FP._1 static getters or FP.Raw._1 const variables.
+FP foo = FP._1 + FP._0_10;
+// or
+foo.RawValue = FP.Raw._1 + FP.Raw._0_10;
+const long MagicNumber = FP.Raw._1 + FP.Raw._0_10;
+
+FP foo = default;
+foo.RawValue = MagicNumber;
+// or
+foo = FP.FromRaw(MagicNumber);
+Convert the specific float once to FP and save the raw value as a constant
+const long MagicNumber = 72089; // 1.1
+
+var foo = FP.FromRaw(MagicNumber);
+// or
+foo.RawValue = MagicNumber;
+Create the constant inside the Quantum DSL
+#define FPConst 1.1
+Then use like this:
+
+var foo = default(FP);
+foo += Constants.FPConst;
+// or
+foo.RawValue += Constants.Raw.FPConst;
+It will generate code to represent the constant in the following way:
+
+public static unsafe partial class Constants {
+  public const Int32 PLAYER_COUNT = 8;
+  /// <summary>1.100006</summary>
+
+  public static FP FPConst {
+    [MethodImpl(MethodImplOptions.AggressiveInlining)] get {
+      FP result;
+      result.RawValue = 72090;
+      return result;
+    }
+  }
+  public static unsafe partial class Raw {
+    /// <summary>1.100006</summary>
+    public const Int64 FPConst = 72090;
+  }
+}
+Define readonly static variables in the class.
+private readonly static FP MagicNumber = FP._1 +  FP._0_10;
+There is a performance penalty compared to const variables and don't forget to mark readonly because randomly changing the value during runtime could lead to desyncs.
+
+Back To Top
+ 
+
+Casting
+Implicit casting to FP from int, uint, short, ushort, byte, sbyte is allowed and safe.
+
+FP v = (FP)1;
+FP v = 1;
+Explicit casting from FP to float or double is possible, but obviously should not be used inside the simulation.
+
+var v = (double)FP._1;
+var v = (float)FP._1;
+Casting to integer and back is safe though.
+
+FP v = (FP)(int)FP._1;
+Unsafe casts are marked as [obsolete] and will cause a InvalidOperationException.
+
+FP v = 1.1f;  // ERROR
+FP v = 1.1d;  // ERROR
+Back To Top
+ 
+
+Inlining
+All low-level Quantum systems use manual inlined FP arithmetic to extract every ounce of performance possible. Fixed point math uses integer division and multiplication. To achieve this, the result or dividend are bit-shifted by the FP-Precision (16) before or after the calculation.
+
+var v = parameter * FP._0_01;
+
+// inlined integer math
+FP v = default;
+v.RawValue = (parameter.RawValue * FP._0_01.RawValue) >> FPLut.PRECISION;
+var v = parameter / FP._0_01;
+
+// inlined integer math
+FP v = default;
+v.RawValue = (parameter.RawValue << FPLut.PRECISION) / FP._0_01.RawValue;
+Back To Top
+ 
+
+Overflow
+FP.UseableMax represents the highest FP number that can be multiplied with itself and not cause an overflow (exceeding long range).
+
+FP.UseableMax
+    Decimal: 32767.9999847412
+    Raw: 2147483647
+    Binary: 1111111111111111111111111111111 = 31 bit
+FP.UseableMin
+    Decimal: -32768
+    Raw: -2147483648
+    Binary: 10000000000000000000000000000000 = 32 bit
+Back To Top
+ 
+
+Precision
+The general FP precision is decent when the numbers are kept within a certain range (0.01..1000). FP-math related precision problems usually produce inaccurate results and tend to make systems (based on math) unstable. A very common case is to multiply very high or small numbers and than returning to the original range by division for example. The resulting numbers lose precision.
+
+Another example is this method excerpt from ClosestDistanceToTriangle. Where t0 is calculated from multiplying two dot products with each other, where a dot-product is already also a result of multiplications. This is a problem when very accurate results are expected. A way to mitigate this issue is shifting the values artificially before the calculation then shift the result back. This will work when the ranges of the input are somewhat known.
+
+var diff = p - v0;
+var edge0 = v1 - v0;
+var edge1 = v2 - v0;
+var a00 = Dot(edge0, edge0);
+var a01 = Dot(edge0, edge1);
+var a11 = Dot(edge1, edge1);
+var b0 = -Dot(diff, edge0);
+var b1 = -Dot(diff, edge1);
+var t0 = a01 * b1 - a11 * b0;
+var t1 = a01 * b0 - a00 * b1;
+// ...
+closestPoint = v0 + t0 * edge0 + t1 * edge1;
+Back To Top
+ 
+
+FPAnimationCurves
+Unity comes with a set of tools which are useful to express some values in the form of curves. It comes with a custom editor for such curves, which are then serialised and can be used in runtime in order to evaluate the value of the curve in some specific point.
+
+There are many situations where curves can be used, such as expressing steering information when implementing vehicles, the utility value during the decision making for an AI agent (as done in Bot SDK's Utility Theory), getting the multiplier value for some attack's damage, and so on.
+
+The Quantum SDK already comes with its own implementation of an animation curve, named FPAnimationCurve, evaluated as FPs. This custom type, when inspected directly on Data Assets and Components in Unity, are drawn with Unity's default Animation Curve editors, whose data are then internally baked into the deterministic type.
+
+Back To Top
+ 
+
+Polling Data From An FPAnimationCurve
+The code needed to poll some data from a curve, with Quantum code, is very similar to the Unity's version:
+
+// This returns the pre-baked value, interpolated accordingly to the curve's configuration such as it's key points, curve's resolution, tangets modes, etc
+FP myValue = myCurve.Evaluate(FP._0_50);
+Back To Top
+ 
+
+Creating FPAnimationCurves Directly On The Simulation
+Here are the snippets to create a deterministic animation curve from scratch, directly on the simulation:
+
+// Creating a simple, linear curve with five key points
+// Change the parameter as prefered
+public static class FPAnimationCurveUtils
+{
+    public static FPAnimationCurve CreateLinearCurve(FPAnimationCurve.WrapMode preWrapMode, FPAnimationCurve.WrapMode postWrapMode)
+    {
+        return new FPAnimationCurve
+        {
+            Samples = new FP[5] { FP._0, FP._0_25, FP._0_50, FP._0_75, FP._1 },
+            PostWrapMode = (int)postWrapMode,
+            PreWrapMode = (int)preWrapMode,
+            StartTime = 0,
+            EndTime = 1,
+            Resolution = 32
+        };
+    }
+}
+// Storing a curve into a local variable
+var curve = FPAnimationCurveUtils.CreateLinearCurve(FPAnimationCurve.WrapMode.Clamp, FPAnimationCurve.WrapMode.Clamp);
+
+// It can also be used directly to pre-initialise a curve in an asset
+public unsafe partial class CollectibleData
+{
+    public FPAnimationCurve myCurve = FPAnimationCurveUtils.CreateLinearCurv

data/Frame.User.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Quantum
+{
+	unsafe partial class Frame
+	{
+	}
+}

data/FrameContext.User.cs

@@ -0,0 +1,7 @@
+namespace Quantum
+{
+	public partial class FrameContextUser
+	{
+
+	}
+}

data/GOAP.User.cs

@@ -0,0 +1,10 @@
+namespace Quantum
+{
+  public unsafe partial struct GOAPAgent
+  {
+    public AIConfig GetConfig(Frame frame)
+    {
+      return frame.FindAsset<AIConfig>(Config.Id);
+    }
+  }
+}

data/GOAP.qtn

@@ -0,0 +1,39 @@
+#define MAX_PLAN_SIZE 6
+
+asset GOAPRoot;
+asset GOAPGoal;
+asset GOAPAction;
+asset GOAPBackValidation;
+
+component GOAPAgent
+{
+	asset_ref<GOAPRoot> Root;
+	AssetRefAIConfig Config;
+
+	[ExcludeFromPrototype]
+	GOAPState CurrentState;
+
+	[ExcludeFromPrototype]
+	asset_ref<GOAPGoal> CurrentGoal;
+	[ExcludeFromPrototype]
+	GOAPState GoalState;
+
+	[ExcludeFromPrototype]
+	sbyte CurrentActionIndex;
+	[ExcludeFromPrototype]
+	sbyte LastProcessedActionIndex;
+	[ExcludeFromPrototype]
+	byte CurrentPlanSize;
+	[ExcludeFromPrototype]
+	array<asset_ref<GOAPAction>>[MAX_PLAN_SIZE] Plan;
+
+	[ExcludeFromPrototype]
+	FP CurrentActionTime;
+	[ExcludeFromPrototype]
+	FP CurrentGoalTime;
+	[ExcludeFromPrototype]
+	FP InterruptionCheckCooldown;
+
+	[ExcludeFromPrototype]
+	list<FP> GoalDisableTimes;
+}

data/GOAPAStar.cs

@@ -0,0 +1,311 @@
+using System;
+using System.Collections.Generic;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	using System.Runtime.InteropServices;
+
+	[StructLayout(LayoutKind.Auto)]
+	public struct GOAPNode
+	{
+		public int         Hash;
+		public byte        Depth;
+		public int         Parent;
+		public sbyte       ActionIndex;
+		public GOAPState   State;
+		public short       F;
+		public short       G;
+
+		public string ToString(GOAPAction[] actions)
+		{
+			string action = ActionIndex >= 0 && ActionIndex < actions.Length ? actions[ActionIndex].Path : "NoAction";
+			return $"{action}, real cost (G): {G / 100f}, total heuristic cost (F): {F / 100f}, hash: {Hash}, parent: {Parent}";
+		}
+	}
+
+	public struct StateBackValidation
+	{
+		public GOAPState ValidatedState;
+		public FP        CostToNextState;
+
+		public StateBackValidation(GOAPState validatedState, FP costToNextState)
+		{
+			ValidatedState = validatedState;
+			CostToNextState = costToNextState;
+		}
+	}
+
+	public unsafe class GOAPAStar
+	{
+		public delegate int HeuristicCost(GOAPState fromState, GOAPState toState);
+
+		// PUBLIC MEMBERS
+
+		public StatisticsData Statistics;
+
+		// PRIVATE MEMBERS
+
+		private readonly Dictionary<int, GOAPNode> _active = new Dictionary<int, GOAPNode>();
+		private readonly Dictionary<int, GOAPNode> _closed = new Dictionary<int, GOAPNode>();
+
+		private readonly GOAPHeap _open = new GOAPHeap();
+
+		private ActionData[] _actionData;
+		private List<GOAPAction> _plan = new List<GOAPAction>(16);
+
+		private List<StateBackValidation> _planStateValidations = new List<StateBackValidation>(8);
+
+		// PUBLIC METHODS
+
+		public List<GOAPAction> Run(Frame frame, GOAPEntityContext context, GOAPState start, GOAPState end, GOAPGoal goal,
+			GOAPAction[] availableActions, HeuristicCost heuristic, int maxPlanSize)
+		{
+			Statistics = default;
+
+			int foundPathEndHash = BackwardAStar(frame, context, start, end, goal, availableActions, heuristic, maxPlanSize);
+
+			Statistics.Success     = foundPathEndHash != 0;
+			Statistics.ClosedNodes = _closed.Count;
+			Statistics.OpenNodes   = _open.Size;
+			Statistics.ActiveNodes = _active.Count;
+
+			if (foundPathEndHash == 0)
+				return null;
+
+			_plan.Clear();
+
+			int nodeHash = foundPathEndHash;
+			while (nodeHash != 0)
+			{
+				if (_closed.TryGetValue(nodeHash, out GOAPNode node))
+				{
+					if (node.ActionIndex >= 0)
+					{
+						_plan.Add(availableActions[node.ActionIndex]);
+					}
+
+					nodeHash = node.Parent;
+				}
+			}
+
+			return _plan;
+		}
+
+		// PRIVATE METHODS
+
+		private int BackwardAStar(Frame frame, GOAPEntityContext context, GOAPState start, GOAPState end, GOAPGoal goal,
+			GOAPAction[] availableActions, HeuristicCost heuristic, int maxPlanSize)
+		{
+			_open.Clear();
+			_closed.Clear();
+			_active.Clear();
+
+			PrepareActionData(ref _actionData, availableActions.Length);
+
+			GOAPNode startNode = new GOAPNode
+			{
+				Hash = end.GetHashCode(),
+				State = end,
+				F = 0,
+				G = 0,
+				Depth = 0,
+				ActionIndex = (sbyte)-1,
+			};
+
+			_open.Push(startNode);
+			_active.Add(startNode.Hash, startNode);
+
+			while (_open.Size > 0)
+			{
+				GOAPNode currentNode = _open.Pop();
+				_closed.Add(currentNode.Hash, currentNode);
+
+				//Log.Warn($"Closing node {currentNode.ToString()}");
+
+				if (start.Contains(currentNode.State) == true)
+					return currentNode.Hash;
+
+				if (currentNode.Depth >= maxPlanSize)
+					continue;
+
+				for (int i = availableActions.Length - 1; i >= 0; i--)
+				{
+					var action = availableActions[i];
+					var actionData = _actionData[i];
+
+					if (actionData.IsProcessed == true && actionData.IsValid == false)
+						continue;
+
+					// Check if action can satisfy state at least partially (backward search)
+					if (currentNode.State.ContainsAny(action.Effects) == false)
+						continue;
+
+					// Check if action will not incorrectly override current state (backward search)
+					// Note: Next few lines are a bit difficult to understand.
+					// Do not modify it unless you know what you are doing.
+					// Mistake here will lead in failed backward search in more complex situations.
+					// Help: Continued state says how state should look like after this action will be executed.
+					// With applied state we are checking whether the current state contains continued state,
+					// merge helps with checking only part of the current state that matters.
+					var continuedState = GOAPState.Merge(action.Conditions, action.Effects);
+					var appliedState = GOAPState.Merge(continuedState, currentNode.State);
+
+					if (appliedState.Contains(continuedState) == false)
+						continue;
+
+					// We are validating action after we decide it fits the plan to not do this
+					// potentially expensive call unnecessary
+					if (actionData.IsProcessed == false)
+					{
+						actionData.IsValid = action.ValidateAction(frame, context, start, out FP cost) && cost > 0;
+						actionData.Cost = cost;
+						actionData.IsProcessed = true;
+
+						Assert.Check(cost > 0, $"GOAP: Action cost has to be greater than zero. Action: {action.Path} Cost: {cost}");
+
+						if (actionData.IsValid == false)
+						{
+							Statistics.ValidationReturns++;
+							continue;
+						}
+					}
+
+					Statistics.ValidationCalls++;
+
+					// Remove effects, apply conditions to state (= backward apply action)
+					GOAPState newState = GOAPState.Remove(currentNode.State, action.Effects);
+					newState.Merge(action.Conditions);
+
+					if (action.UsePlanStateValidation == true)
+					{
+						_planStateValidations.Clear();
+
+						action.ValidatePlanState(frame, context, newState, currentNode.State, actionData.Cost, _planStateValidations);
+
+						Statistics.PlanStateValidationCalls++;
+
+						// With plan state validation the plan can branch
+						for (int j = 0; j < _planStateValidations.Count; j++)
+						{
+							var validation = _planStateValidations[j];
+							TryAddNode(currentNode, validation.ValidatedState, i, validation.CostToNextState, start, heuristic);
+						}
+					}
+					else
+					{
+						TryAddNode(currentNode, newState, i, actionData.Cost, start, heuristic);
+					}
+				}
+			}
+
+			return 0;
+		}
+
+		private void TryAddNode(GOAPNode currentNode, GOAPState newState, int actionIndex, FP actionCost, GOAPState start, HeuristicCost heuristic)
+		{
+			int newStateHash = newState.GetHashCode();
+
+			if (_closed.ContainsKey(newStateHash) == true)
+			{
+				Statistics.InClosedReturns++;
+				return;
+			}
+
+			short h = (short)(heuristic(start, newState) * 100);
+			short g = (short)(currentNode.G + actionCost * 100);
+
+			Statistics.ProcessedNodes++;
+
+			GOAPNode node = new GOAPNode
+			{
+				Hash        = newStateHash,
+				State       = newState,
+				ActionIndex = (sbyte)actionIndex,
+				G           = g,
+				F           = (short)(h + g),
+				Parent      = currentNode.Hash,
+				Depth       = (byte)(currentNode.Depth + 1),
+			};
+
+			if (_active.TryGetValue(node.Hash, out GOAPNode existing))
+			{
+				if (node.F >= existing.F)
+					return;
+
+				_open.Update(node);
+				_active[node.Hash] = node;
+
+				//Log.Warn($"Updating node {node.ToString()}");
+			}
+			else
+			{
+				_open.Push(node);
+				_active.Add(node.Hash, node);
+
+				//Log.Warn($"Adding node {node.ToString()}");
+			}
+		}
+
+		private static void PrepareActionData(ref ActionData[] actionData, int length)
+		{
+			int originalLength = actionData != null ? actionData.Length : 0;
+
+			if (originalLength < length)
+			{
+				Array.Resize(ref actionData, length);
+			}
+
+			for (int i = 0; i < length; i++)
+			{
+				if (i < originalLength)
+				{
+					actionData[i].IsProcessed = false;
+				}
+				else
+				{
+					actionData[i] = new ActionData();
+				}
+			}
+		}
+
+		private void PrintHeap(GOAPAction[] actions)
+		{
+			string heap = "HEAP: ";
+			int index = 0;
+
+			foreach (GOAPNode node in _open)
+			{
+				heap += $"{index}: COST: {node.F} {actions[node.ActionIndex].Path}\n";
+				index++;
+			}
+
+			Log.Info(heap);
+		}
+
+		private class ActionData
+		{
+			public bool IsProcessed;
+			public bool IsValid;
+			public FP   Cost;
+		}
+
+		public struct StatisticsData
+		{
+			public bool Success;
+			public int  ClosedNodes;
+			public int  OpenNodes;
+			public int  ActiveNodes;
+			public int  ValidationCalls;
+			public int  ValidationReturns;
+			public int  PlanStateValidationCalls;
+			public int  InClosedReturns;
+			public int  ProcessedNodes;
+
+			public new string ToString()
+			{
+				return $"Success: {Success}, Closed: {ClosedNodes}, Open: {OpenNodes}, Active: {ActiveNodes}\nValidation calls: {ValidationCalls}\nValidation returns: {ValidationReturns}\nPlan State Validation calls: {PlanStateValidationCalls}\nIn Closed returns: {InClosedReturns}\n Processed nodes: {ProcessedNodes}";
+			}
+		}
+	}
+}

data/GOAPAction.cs

@@ -0,0 +1,53 @@
+using Photon.Deterministic;
+using System.Collections.Generic;
+
+namespace Quantum
+{
+	public abstract unsafe partial class GOAPAction
+	{
+		public enum EResult
+		{
+			Continue,
+			IsDone,
+			IsFailed,
+		}
+
+		// PUBLIC MEMBERS
+
+		public string    Label;
+
+		[BotSDKHidden]
+		public GOAPState Conditions;
+		[BotSDKHidden]
+		public GOAPState Effects;
+
+		public bool      Interruptible;
+
+		public abstract bool UsePlanStateValidation { get; }
+
+		// PUBLIC METHODS
+
+		public virtual bool ValidateAction(Frame frame, GOAPEntityContext context, GOAPState startState, out FP cost)
+		{
+			cost = 1;
+			return true;
+		}
+
+		public virtual void ValidatePlanState(Frame frame, GOAPEntityContext context, GOAPState stateToValidate, GOAPState nextState, FP costToNextState, List<StateBackValidation> validatedStates)
+		{
+		}
+
+		public virtual void Activate(Frame frame, GOAPEntityContext context)
+		{
+		}
+
+		public virtual EResult Update(Frame frame, GOAPEntityContext context)
+		{
+			return EResult.Continue;
+		}
+
+		public virtual void Deactivate(Frame frame, GOAPEntityContext context)
+		{
+		}
+	}
+}

data/GOAPBackValidation.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using Photon.Deterministic;
+
+
+namespace Quantum
+{
+	public abstract partial class GOAPBackValidation
+	{
+		public abstract void ValidatePlanState(Frame frame, EntityRef entity, GOAPState stateToValidate, GOAPState nextState, FP costToNextState, List<StateBackValidation> validatedStates);
+	}
+
+	public abstract class GOAPSingleBackValidation : GOAPBackValidation
+	{
+		public override sealed void ValidatePlanState(Frame frame, EntityRef entity, GOAPState stateToValidate, GOAPState nextState, FP costToNextState,
+			List<StateBackValidation> validatedStates)
+		{
+			if (ValidatePlanState(frame, entity, ref stateToValidate, nextState, ref costToNextState) == true)
+			{
+				validatedStates.Add(new StateBackValidation(stateToValidate, costToNextState));
+			}
+		}
+
+		protected virtual bool ValidatePlanState(Frame frame, EntityRef entity, ref GOAPState stateToValidate, GOAPState nextState, ref FP costToNextState)
+		{
+			return false;
+		}
+	}
+}

data/GOAPDefaultAction.cs

@@ -0,0 +1,122 @@
+using Photon.Deterministic;
+using System.Collections.Generic;
+using System;
+
+namespace Quantum
+{
+	[Serializable]
+	public unsafe partial class GOAPDefaultAction : GOAPAction
+	{
+		// PUBLIC MEMBERS
+
+		public AIParamBool                  Validation = true;
+		public AIParamFP                    Cost = FP._1;
+		public AssetRefGOAPBackValidation   PlanStateValidationLink;
+
+		public AssetRefAIAction[] OnActivateLinks;
+		public AssetRefAIAction[] OnUpdateLinks;
+		public AssetRefAIAction[] OnDeactivateLinks;
+
+		public AIParamBool IsDone;
+		public AIParamBool IsFailed;
+
+		[NonSerialized]
+		public GOAPBackValidation PlanStateValidation;
+
+		[NonSerialized]
+		public AIAction[] OnActivate;
+		[NonSerialized]
+		public AIAction[] OnUpdate;
+		[NonSerialized]
+		public AIAction[] OnDeactivate;
+
+		public override bool UsePlanStateValidation => PlanStateValidation != null;
+
+		// PUBLIC METHODS
+
+		public override bool ValidateAction(Frame frame, GOAPEntityContext context, GOAPState startState, out FP cost)
+		{
+			cost = FP.MaxValue;
+
+			if (Validation.Resolve(frame, context.Entity, context.Blackboard, context.Config) == false)
+				return false;
+
+			cost = Cost.Resolve(frame, context.Entity, context.Blackboard, context.Config);
+
+			return cost < FP.MaxValue;
+		}
+
+		public override void ValidatePlanState(Frame frame, GOAPEntityContext context, GOAPState stateToValidate, GOAPState nextState, FP costToNextState, List<StateBackValidation> validatedStates)
+		{
+			PlanStateValidation.ValidatePlanState(frame, context.Entity, stateToValidate, nextState, costToNextState, validatedStates);
+		}
+
+		public override void Activate(Frame frame, GOAPEntityContext context)
+		{
+			ExecuteActions(frame, context.Entity, OnActivate);
+		}
+
+		public override EResult Update(Frame frame, GOAPEntityContext context)
+		{
+			if (IsDone.Resolve(frame, context.Entity, context.Blackboard, context.Config) == true)
+				return EResult.IsDone;
+
+			if (IsFailed.Resolve(frame, context.Entity, context.Blackboard, context.Config) == true)
+				return EResult.IsFailed;
+
+			ExecuteActions(frame, context.Entity, OnUpdate);
+
+			return EResult.Continue;
+		}
+
+		public override void Deactivate(Frame frame, GOAPEntityContext context)
+		{
+			ExecuteActions(frame, context.Entity, OnDeactivate);
+		}
+
+		// AssetObject INTERFACE
+
+		public override void Loaded(IResourceManager resourceManager, Native.Allocator allocator)
+		{
+			base.Loaded(resourceManager, allocator);
+
+			PlanStateValidation = (GOAPBackValidation)resourceManager.GetAsset(PlanStateValidationLink.Id);
+
+			OnActivate = new AIAction[OnActivateLinks == null ? 0 : OnActivateLinks.Length];
+			for (int i = 0; i < OnActivate.Length; i++)
+			{
+				OnActivate[i] = (AIAction)resourceManager.GetAsset(OnActivateLinks[i].Id);
+			}
+
+			OnUpdate = new AIAction[OnUpdateLinks == null ? 0 : OnUpdateLinks.Length];
+			for (int i = 0; i < OnUpdate.Length; i++)
+			{
+				OnUpdate[i] = (AIAction)resourceManager.GetAsset(OnUpdateLinks[i].Id);
+			}
+
+			OnDeactivate = new AIAction[OnDeactivateLinks == null ? 0 : OnDeactivateLinks.Length];
+			for (int i = 0; i < OnDeactivate.Length; i++)
+			{
+				OnDeactivate[i] = (AIAction)resourceManager.GetAsset(OnDeactivateLinks[i].Id);
+			}
+		}
+
+		// PRIVATE METHODS
+
+		private static void ExecuteActions(Frame frame, EntityRef entity, AIAction[] actions)
+		{
+			for (int i = 0; i < actions.Length; i++)
+			{
+				var action = actions[i];
+
+				action.Update(frame, entity);
+
+				int nextAction = action.NextAction(frame, entity);
+				if (nextAction > i)
+				{
+					i = nextAction;
+				}
+			}
+		}
+	}
+}

data/GOAPDefaultGoal.cs

@@ -0,0 +1,113 @@
+using System;
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	[Serializable]
+	public unsafe partial class GOAPDefaultGoal : GOAPGoal
+	{
+		// PUBLIC MEMBERS
+
+		public AIParamBool          Validation = true;
+		public AIParamFP            Relevancy = FP._1;
+		public AIParamFP            DisableTime;
+		public AssetRefAIAction[]   OnInitPlanningLinks;
+		public AssetRefAIAction[]   OnActivateLinks;
+		public AssetRefAIAction[]   OnDeactivateLinks;
+		public AIParamBool          IsFinished;
+
+		[NonSerialized]
+		public AIAction[] OnInitPlanning;
+		[NonSerialized]
+		public AIAction[] OnActivate;
+		[NonSerialized]
+		public AIAction[] OnDeactivate;
+
+		// PUBLIC METHODS
+
+		public override FP GetRelevancy(Frame frame, GOAPEntityContext context)
+		{
+			if (Validation.Resolve(frame, context.Entity, context.Blackboard, context.Config) == false)
+				return 0;
+
+			return Relevancy.Resolve(frame, context.Entity, context.Blackboard, context.Config);
+		}
+
+		public override void InitPlanning(Frame frame, GOAPEntityContext context, ref GOAPState startState, ref GOAPState targetState)
+		{
+			base.InitPlanning(frame, context, ref startState, ref targetState);
+
+			ExecuteActions(frame, context.Entity, OnInitPlanning);
+		}
+
+		public override void Activate(Frame frame, GOAPEntityContext context)
+		{
+			base.Activate(frame, context);
+
+			ExecuteActions(frame, context.Entity, OnActivate);
+		}
+
+		public override void Deactivate(Frame frame, GOAPEntityContext context)
+		{
+			ExecuteActions(frame, context.Entity, OnDeactivate);
+
+			base.Deactivate(frame, context);
+		}
+
+		public override bool HasFinished(Frame frame, GOAPEntityContext context)
+		{
+			if (base.HasFinished(frame, context) == true)
+				return true;
+
+			return IsFinished.Resolve(frame, context.Entity, context.Blackboard, context.Config);
+		}
+
+		public override FP GetDisableTime(Frame frame, GOAPEntityContext context)
+		{
+			return DisableTime.Resolve(frame, context.Entity, context.Blackboard, context.Config);
+		}
+
+		// AssetObject INTERFACE
+
+		public override void Loaded(IResourceManager resourceManager, Native.Allocator allocator)
+		{
+			base.Loaded(resourceManager, allocator);
+
+			OnInitPlanning = new AIAction[OnInitPlanningLinks == null ? 0 : OnInitPlanningLinks.Length];
+			for (int i = 0; i < OnInitPlanning.Length; i++)
+			{
+				OnInitPlanning[i] = (AIAction)resourceManager.GetAsset(OnInitPlanningLinks[i].Id);
+			}
+
+			OnActivate = new AIAction[OnActivateLinks == null ? 0 : OnActivateLinks.Length];
+			for (int i = 0; i < OnActivate.Length; i++)
+			{
+				OnActivate[i] = (AIAction)resourceManager.GetAsset(OnActivateLinks[i].Id);
+			}
+
+			OnDeactivate = new AIAction[OnDeactivateLinks == null ? 0 : OnDeactivateLinks.Length];
+			for (int i = 0; i < OnDeactivate.Length; i++)
+			{
+				OnDeactivate[i] = (AIAction)resourceManager.GetAsset(OnDeactivateLinks[i].Id);
+			}
+		}
+
+		// PRIVATE METHODS
+
+		private static void ExecuteActions(Frame frame, EntityRef entity, AIAction[] actions)
+		{
+			for (int i = 0; i < actions.Length; i++)
+			{
+				var action = actions[i];
+
+				action.Update(frame, entity);
+
+				int nextAction = action.NextAction(frame, entity);
+				if (nextAction > i)
+				{
+					i = nextAction;
+				}
+			}
+		}
+	}
+}

data/GOAPDefaultHeuristic.cs

@@ -0,0 +1,45 @@
+namespace Quantum
+{
+	public static class GOAPDefaultHeuristic
+	{
+		public static int BitmaskDifferenceUInt32(GOAPState start, GOAPState end)
+		{
+			EWorldState positiveAchieved = start.Positive & end.Positive;
+			EWorldState negativeAchieved = start.Negative & end.Negative;
+
+			EWorldState positiveMissing = end.Positive & ~positiveAchieved;
+			EWorldState negativeMissing = end.Negative & ~negativeAchieved;
+
+			return CountOnesUInt32((uint) positiveMissing) + CountOnesUInt32((uint) negativeMissing);
+		}
+
+		public static int BitmaskDifferenceUInt64(GOAPState start, GOAPState end)
+		{
+			EWorldState positiveAchieved = start.Positive & end.Positive;
+			EWorldState negativeAchieved = start.Negative & end.Negative;
+
+			EWorldState positiveMissing = end.Positive & ~positiveAchieved;
+			EWorldState negativeMissing = end.Negative & ~negativeAchieved;
+
+			return CountOnesUInt64((ulong) positiveMissing) + CountOnesUInt64((ulong) negativeMissing);
+		}
+
+		public static int CountOnesUInt32(uint x)
+		{
+			x = x - ((x >> 1) & 0x55555555u);
+			x = (x & 0x33333333u) + ((x >> 2) & 0x33333333u);
+			x = (x + (x >> 4)) & 0x0F0F0F0Fu;
+
+			return (int) ((x * 0x01010101u) >> 24);
+		}
+
+		public static int CountOnesUInt64(ulong x)
+		{
+			x = x - ((x >> 1) & 0x5555555555555555ul);
+			x = (x & 0x3333333333333333ul) + ((x >> 2) & 0x3333333333333333ul);
+			x = (x + (x >> 4)) & 0xF0F0F0F0F0F0F0Ful;
+
+			return (int) (x * 0x101010101010101ul >> 56);
+		}
+	}
+}

data/GOAPGoal.cs

@@ -0,0 +1,66 @@
+using Photon.Deterministic;
+
+namespace Quantum
+{
+	public abstract unsafe partial class GOAPGoal
+	{
+		public enum EInterruptionBehavior
+		{
+			Never,
+			Always,
+			BasedOnActions,
+		}
+
+		// PUBLIC MEMBERS
+
+		public string                Label;
+
+		[BotSDKHidden]
+		public GOAPState             StartState;
+		[BotSDKHidden]
+		public GOAPState             TargetState;
+		public EInterruptionBehavior InterruptionBehavior;
+
+		// PUBLIC INTERFACE
+
+		public virtual FP GetRelevancy(Frame frame, GOAPEntityContext context)
+		{
+			return 1;
+		}
+
+		public virtual void InitPlanning(Frame frame, GOAPEntityContext context, ref GOAPState startState, ref GOAPState targetState)
+		{
+			startState.Merge(StartState);
+			targetState.Merge(TargetState);
+		}
+
+		public virtual void Activate(Frame frame, GOAPEntityContext context)
+		{
+		}
+
+		public virtual void Deactivate(Frame frame, GOAPEntityContext context)
+		{
+		}
+
+		public virtual bool HasFinished(Frame frame, GOAPEntityContext context)
+		{
+			return context.Agent->CurrentState.Contains(context.Agent->GoalState);
+		}
+
+		public bool IsInterruptible(GOAPAction currentAction)
+		{
+			if (InterruptionBehavior == EInterruptionBehavior.Never)
+				return false;
+
+			if (InterruptionBehavior == EInterruptionBehavior.Always)
+				return true;
+
+			return currentAction != null && currentAction.Interruptible;
+		}
+
+		public virtual FP GetDisableTime(Frame frame, GOAPEntityContext context)
+		{
+			return 0;
+		}
+	}
+}

data/GOAPHeap.cs

@@ -0,0 +1,162 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Quantum
+{
+	public class GOAPHeap : IEnumerable, IEnumerable<GOAPNode>
+	{
+		private GOAPNode[] _heap;
+		private int _size;
+
+		public GOAPHeap(int capacity)
+		{
+			_heap = new GOAPNode[capacity];
+		}
+
+		public GOAPHeap() : this(1024)
+		{
+		}
+
+		public int Size { get { return _size; } }
+
+		public void Clear()
+		{
+			_size = 0;
+
+			// remove all stuff from heap
+			Array.Clear(_heap, 0, _heap.Length);
+		}
+
+		public void Update(GOAPNode updateNode)
+		{
+			int bubbleIndex = -1;
+			for (int i = 0; i < _size; i++)
+			{
+				var node = _heap[i];
+				if (node.Hash == updateNode.Hash)
+				{
+					bubbleIndex = i;
+					break;
+				}
+			}
+
+			if (bubbleIndex < 0)
+			{
+				Log.Error($"Cannot update node: Node with hash {updateNode.Hash} is not present in the heap");
+				return;
+			}
+
+			_heap[bubbleIndex] = updateNode;
+
+			while (bubbleIndex != 0)
+			{
+				int parentIndex = (bubbleIndex - 1) / 2;
+
+				if (_heap[parentIndex].F <= updateNode.F)
+					break;
+
+				_heap[bubbleIndex] = _heap[parentIndex];
+				_heap[parentIndex] = updateNode;
+
+				bubbleIndex = parentIndex;
+			}
+		}
+
+		public void Push(GOAPNode node)
+		{
+			if (_size == _heap.Length)
+			{
+				ExpandHeap();
+			}
+
+			int bubbleIndex = _size;
+			_heap[bubbleIndex] = node;
+
+			_size++;
+
+			while (bubbleIndex != 0)
+			{
+				int parentIndex = (bubbleIndex - 1) / 2;
+				if (_heap[parentIndex].F <= node.F)
+					break;
+
+				_heap[bubbleIndex] = _heap[parentIndex];
+				_heap[parentIndex] = node;
+
+				bubbleIndex = parentIndex;
+			}
+		}
+
+		public GOAPNode Pop()
+		{
+			GOAPNode returnItem = _heap[0];
+			_heap[0] = _heap[_size - 1];
+
+			_size--;
+
+			int swapItem = 0;
+			int parent = 0;
+
+			do
+			{
+				parent = swapItem;
+
+				int leftChild = 2 * parent + 1;
+				int rightChild = 2 * parent + 2;
+
+				if (rightChild <= _size)
+				{
+					int smallerChild = _heap[leftChild].F < _heap[rightChild].F ? leftChild : rightChild;
+
+					if (_heap[parent].F >= _heap[smallerChild].F)
+					{
+						swapItem = smallerChild;
+					}
+				}
+				else if (leftChild <= _size)
+				{
+					// Only one child exists
+					if (_heap[parent].F >= _heap[leftChild].F)
+					{
+						swapItem = leftChild;
+					}
+				}
+
+				// One if the parent's children are smaller or equal, swap them
+				if (parent != swapItem)
+				{
+					GOAPNode tmpIndex = _heap[parent];
+
+					_heap[parent] = _heap[swapItem];
+					_heap[swapItem] = tmpIndex;
+				}
+			}
+			while (parent != swapItem);
+
+			return returnItem;
+		}
+
+		private void ExpandHeap()
+		{
+			// Double the size
+			GOAPNode[] newHeap = new GOAPNode[_heap.Length * 2];
+
+			Array.Copy(_heap, newHeap, _heap.Length);
+			_heap = newHeap;
+		}
+
+		IEnumerator<GOAPNode> IEnumerable<GOAPNode>.GetEnumerator()
+		{
+			for (int i = 0; i < _size; i++)
+			{
+				yield return _heap[i];
+			}
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return (this as IEnumerable<GOAPNode>).GetEnumerator();
+		}
+	}
+}

data/GOAPHeuristic.cs

@@ -0,0 +1,45 @@
+namespace Quantum
+{
+	public static class GOAPHeuristic
+	{
+		public static int BitmaskDifferenceUInt32(GOAPState start, GOAPState end)
+		{
+			EWorldState positiveAchieved = start.Positive & end.Positive;
+			EWorldState negativeAchieved = start.Negative & end.Negative;
+
+			EWorldState positiveMissing = end.Positive & ~positiveAchieved;
+			EWorldState negativeMissing = end.Negative & ~negativeAchieved;
+
+			return CountOnesUInt32((uint) positiveMissing) + CountOnesUInt32((uint) negativeMissing);
+		}
+
+		public static int BitmaskDifferenceUInt64(GOAPState start, GOAPState end)
+		{
+			EWorldState positiveAchieved = start.Positive & end.Positive;
+			EWorldState negativeAchieved = start.Negative & end.Negative;
+
+			EWorldState positiveMissing = end.Positive & ~positiveAchieved;
+			EWorldState negativeMissing = end.Negative & ~negativeAchieved;
+
+			return CountOnesUInt64((ulong) positiveMissing) + CountOnesUInt64((ulong) negativeMissing);
+		}
+
+		public static int CountOnesUInt32(uint x)
+		{
+			x = x - ((x >> 1) & 0x55555555u);
+			x = (x & 0x33333333u) + ((x >> 2) & 0x33333333u);
+			x = (x + (x >> 4)) & 0x0F0F0F0Fu;
+
+			return (int) ((x * 0x01010101u) >> 24);
+		}
+
+		public static int CountOnesUInt64(ulong x)
+		{
+			x = x - ((x >> 1) & 0x5555555555555555ul);
+			x = (x & 0x3333333333333333ul) + ((x >> 2) & 0x3333333333333333ul);
+			x = (x + (x >> 4)) & 0xF0F0F0F0F0F0F0Ful;
+
+			return (int) (x * 0x101010101010101ul >> 56);
+		}
+	}
+}

data/GOAPManager.cs

@@ -0,0 +1,450 @@
+using System;
+using Photon.Deterministic;
+using System.Collections.Generic;
+
+namespace Quantum
+{
+	public static unsafe class GOAPManager
+	{
+		// PUBLIC MEMBERS
+
+		public static EntityRef DebugEntity;
+
+		// PRIVATE MEMBERS
+
+		private static GOAPAStar.HeuristicCost _heuristicCost;
+
+		// PUBLIC METHODS
+
+		public static void Initialize(Frame frame, EntityRef entity, GOAPRoot root, GOAPAStar.HeuristicCost heuristicCost = null)
+		{
+			var agent = frame.Unsafe.GetPointer<GOAPAgent>(entity);
+			agent->Root = root;
+
+			var disableTimes = frame.AllocateList<FP>(root.Goals.Length);
+			for (int i = 0; i < root.GoalRefs.Length; i++)
+			{
+				disableTimes.Add(0);
+			}
+
+			agent->GoalDisableTimes = disableTimes;
+
+			if (heuristicCost != null)
+			{
+				_heuristicCost = heuristicCost;
+			}
+			else if (_heuristicCost == null)
+			{
+				switch (sizeof(EWorldState))
+				{
+					case 4:
+						_heuristicCost = GOAPHeuristic.BitmaskDifferenceUInt32;
+						break;
+					//case 8:
+					//	_heuristicCost = GOAPHeuristic.BitmaskDifferenceUInt64;
+					//	break;
+					default:
+						throw new NotImplementedException($"Heuristic for EWorldState size of {sizeof(EWorldState)} bytes is not implemented");
+				}
+			}
+		}
+
+		public static void Deinitialize(Frame frame, EntityRef entity)
+		{
+			var agent = frame.Unsafe.GetPointer<GOAPAgent>(entity);
+
+			agent->Root = default;
+
+			frame.FreeList(agent->GoalDisableTimes);
+			agent->GoalDisableTimes = default;
+		}
+
+		public static void Update(Frame frame, EntityRef entity, FP deltaTime)
+		{
+			var context = GetContext(frame, entity);
+			var agent = context.Agent;
+
+			bool debug = DebugEntity == entity;
+
+			// Update disable times
+			var goalDisableTimes = frame.ResolveList(agent->GoalDisableTimes);
+			for (int i = 0; i < goalDisableTimes.Count; i++)
+			{
+				goalDisableTimes[i] = FPMath.Max(FP._0, goalDisableTimes[i] - deltaTime);
+			}
+
+			var currentGoal = agent->CurrentGoal.Id.IsValid == true ? frame.FindAsset<GOAPGoal>(agent->CurrentGoal.Id) : null;
+			var currentAction = GetCurrentAction(frame, agent);
+
+			if (currentGoal != null)
+			{
+				// Decrease interruption timer
+				agent->InterruptionCheckCooldown = FPMath.Max(agent->InterruptionCheckCooldown - deltaTime, 0);
+
+				if (currentGoal.HasFinished(frame, context) == true)
+				{
+					StopCurrentGoal(frame, context, ref currentGoal, ref currentAction);
+				}
+			}
+
+			if (currentGoal == null || (agent->InterruptionCheckCooldown <= 0 && currentGoal.IsInterruptible(currentAction) == true))
+			{
+				FindNewGoal(frame, context, ref currentGoal, ref currentAction);
+			}
+
+			if (currentGoal != null)
+			{
+				UpdateCurrentGoal(frame, context, deltaTime, ref currentGoal, ref currentAction);
+			}
+
+			Pool.Return(context);
+		}
+
+		public static void StopCurrentGoal(Frame frame, EntityRef entity)
+		{
+			var context = GetContext(frame, entity);
+
+			var currentGoal = context.Agent->CurrentGoal.Id.IsValid == true ? frame.FindAsset<GOAPGoal>(context.Agent->CurrentGoal.Id) : null;
+			var currentAction = GetCurrentAction(frame, context.Agent);
+
+			StopCurrentGoal(frame, context, ref currentGoal, ref currentAction);
+		}
+
+		public static void SetGoalDisableTime(Frame frame, EntityRef entity, AssetRefGOAPGoal goal, FP disableTime)
+		{
+			if (goal.Id.IsValid == false)
+				return;
+
+			var agent = frame.Unsafe.GetPointer<GOAPAgent>(entity);
+
+			if (goal == agent->CurrentGoal)
+			{
+				StopCurrentGoal(frame, entity);
+			}
+
+			var root = frame.FindAsset<GOAPRoot>(agent->Root.Id);
+			int goalIndex = Array.IndexOf(root.GoalRefs, goal);
+
+			if (goalIndex >= 0)
+			{
+				var disableTimes = frame.ResolveList(agent->GoalDisableTimes);
+				disableTimes[goalIndex] = disableTime;
+			}
+		}
+
+		// PRIVATE METHODS
+
+		private static void UpdateCurrentGoal(Frame frame, GOAPEntityContext context, FP deltaTime, ref GOAPGoal currentGoal, ref GOAPAction currentAction)
+		{
+			var agent = context.Agent;
+			bool debug = DebugEntity == context.Entity;
+
+			if (currentAction != null && agent->CurrentState.Contains(currentAction.Effects) == true)
+			{
+				// This action is done, let's choose another one in next step
+				StopCurrentAction(frame, context, ref currentAction);
+			}
+
+			// Activate next action from the plan if needed
+			if (currentAction == null && agent->CurrentPlanSize > 0)
+			{
+				while (agent->CurrentActionIndex < agent->CurrentPlanSize - 1)
+				{
+					agent->LastProcessedActionIndex = agent->CurrentActionIndex;
+					agent->CurrentActionIndex++;
+
+					var nextAction = frame.FindAsset<GOAPAction>(agent->Plan[agent->CurrentActionIndex].Id);
+
+					if (agent->CurrentState.Contains(nextAction.Conditions) == false)
+					{
+						// Conditions are not met, terminate whole plan
+						StopCurrentGoal(frame, context, ref currentGoal, ref currentAction);
+						break;
+					}
+
+					if (agent->CurrentState.Contains(nextAction.Effects) == false)
+					{
+						// This action is valid, activate it
+						currentAction = nextAction;
+						currentAction.Activate(frame, context);
+
+						if (debug == true)
+						{
+							Log.Info($"GOAP: Action {currentAction.Path} activated");
+						}
+
+						agent->CurrentActionTime = 0;
+						break;
+					}
+				}
+
+				if (currentAction == null && currentGoal != null)
+				{
+					if (debug == true)
+					{
+						Log.Info($"GOAP: Plan execution failed: Probably last action is finished but goal is not satisfied (state might change during execution). Goal: {currentGoal.Path}");
+					}
+
+					StopCurrentGoal(frame, context, ref currentGoal, ref currentAction);
+				}
+			}
+
+			// Update action
+			if (currentAction != null)
+			{
+				var result = currentAction.Update(frame, context);
+
+				if (result == GOAPAction.EResult.IsFailed)
+				{
+					StopCurrentGoal(frame, context, ref currentGoal, ref currentAction);
+				}
+				else if (result == GOAPAction.EResult.IsDone)
+				{
+					// This action claims to be done, apply effects and next action will be chosen next Update
+					agent->CurrentState.Merge(currentAction.Effects);
+					agent->LastProcessedActionIndex = agent->CurrentActionIndex;
+
+					StopCurrentAction(frame, context, ref currentAction);
+				}
+
+				agent->CurrentActionTime += deltaTime;
+			}
+
+			if (currentGoal != null)
+			{
+				agent->CurrentGoalTime += deltaTime;
+			}
+		}
+
+		private static void StopCurrentAction(Frame frame, GOAPEntityContext context, ref GOAPAction currentAction)
+		{
+			if (currentAction == null)
+				return;
+
+			if (context.Agent->Plan[context.Agent->CurrentActionIndex] != currentAction)
+			{
+				Log.Error($"GOAP: Trying to stop action {currentAction.Path} that isn't currently active.");
+				return;
+			}
+
+			currentAction.Deactivate(frame, context);
+			context.Agent->LastProcessedActionIndex = context.Agent->CurrentActionIndex;
+
+			if (context.Entity == DebugEntity)
+			{
+				Log.Info($"GOAP: Action {currentAction.Path} deactivated");
+			}
+
+			currentAction = null;
+		}
+
+		private static void StopCurrentGoal(Frame frame, GOAPEntityContext context, ref GOAPGoal currentGoal, ref GOAPAction currentAction)
+		{
+			var agent = context.Agent;
+
+			StopCurrentAction(frame, context, ref currentAction);
+
+			if (currentGoal != null)
+			{
+				currentGoal.Deactivate(frame, context);
+
+				if (context.Entity == DebugEntity)
+				{
+					Log.Info($"GOAP: Goal {currentGoal.Path} deactivated");
+				}
+
+				FP disableTime = currentGoal.GetDisableTime(frame, context);
+				if (disableTime > 0)
+				{
+					var disableTimes = frame.ResolveList(agent->GoalDisableTimes);
+
+					int goalIndex = Array.IndexOf(context.Root.Goals, currentGoal);
+					if (goalIndex >= 0)
+					{
+						disableTimes[goalIndex] = disableTime;
+					}
+				}
+			}
+
+			agent->CurrentActionIndex = -1;
+			agent->LastProcessedActionIndex = -1;
+			agent->CurrentActionTime = 0;
+
+			agent->CurrentPlanSize = 0;
+			agent->CurrentGoal = default;
+			agent->CurrentGoalTime = 0;
+
+			currentGoal = null;
+			currentAction = null;
+		}
+
+		private static void FindNewGoal(Frame frame, GOAPEntityContext context, ref GOAPGoal currentGoal, ref GOAPAction currentAction)
+		{
+			var agent = context.Agent;
+			var goals = context.Root.Goals;
+
+			GOAPGoal bestGoal = null;
+			FP bestRelevancy = FP.MinValue;
+
+			var disableTimes = frame.ResolveList(agent->GoalDisableTimes);
+			for (int i = 0; i < goals.Length; i++)
+			{
+				if (disableTimes[i] > 0)
+					continue;
+
+				var goal = goals[i];
+
+				var startState = agent->CurrentState;
+				startState.Merge(goal.StartState);
+
+				if (startState.Contains(goal.TargetState) == true)
+					continue; // Goal is satisfied
+
+				FP relevancy = goal.GetRelevancy(frame, context);
+
+				if (relevancy <= 0)
+					continue;
+
+				if (relevancy > bestRelevancy)
+				{
+					bestRelevancy = relevancy;
+					bestGoal = goal;
+				}
+			}
+
+			// Reset interruption timer
+			agent->InterruptionCheckCooldown = context.Root.InterruptionCheckInterval;
+
+			if (bestGoal == null || bestGoal == currentGoal)
+				return;
+
+			bool debug = context.Entity == DebugEntity;
+
+			if (debug == true)
+			{
+				Log.Info($"GOAP: New best goal found: {bestGoal.Path}");
+			}
+
+			GOAPState currentState = agent->CurrentState;
+			GOAPState targetState = default;
+
+			bestGoal.InitPlanning(frame, context, ref currentState, ref targetState);
+
+			var aStar = Pool<GOAPAStar>.Get();
+			List<GOAPAction> plan = null;
+
+			if (debug == true)
+			{
+				using (new StopwatchBlock("GOAP: Backward A* search"))
+				{
+					plan = aStar.Run(frame, context, currentState, targetState, bestGoal, context.Root.Actions, _heuristicCost, Constants.MAX_PLAN_SIZE);
+				}
+
+				Log.Info($"GOAP: Search data - {aStar.Statistics.ToString()}");
+			}
+			else
+			{
+				plan = aStar.Run(frame, context, currentState, targetState, bestGoal, context.Root.Actions, _heuristicCost, Constants.MAX_PLAN_SIZE);
+			}
+
+			if (plan == null)
+			{
+				if (debug == true)
+				{
+					Log.Info($"GOAP: Failed to find plan for goal {bestGoal.Path}");
+				}
+
+				int goalIndex = Array.IndexOf(goals, bestGoal);
+				// Ensure there will be at least one planning without this failed goal
+				disableTimes[goalIndex] = FPMath.Max(FP._0_50, agent->InterruptionCheckCooldown + FP._0_10);
+
+				Pool<GOAPAStar>.Return(aStar);
+
+				return;
+			}
+
+			if (currentGoal != null)
+			{
+				StopCurrentGoal(frame, context, ref currentGoal, ref currentAction);
+			}
+
+			agent->CurrentGoal = bestGoal;
+			agent->CurrentGoalTime = 0;
+			agent->CurrentState = currentState;
+			agent->GoalState = targetState;
+
+			agent->CurrentActionIndex = -1;
+			agent->LastProcessedActionIndex = -1;
+			agent->CurrentActionTime = 0;
+			agent->CurrentPlanSize = 0;
+
+			currentGoal = bestGoal;
+			currentAction = null;
+
+			for (int i = 0; i < plan.Count; i++)
+			{
+				var action = plan[i];
+				if (action == null)
+					break;
+
+				*agent->Plan.GetPointer(i) = action;
+				agent->CurrentPlanSize++;
+			}
+
+			if (debug == true)
+			{
+				var planInfo = $"GOAP: Plan FOUND. Size: {agent->CurrentPlanSize} More...";
+				for (int i = 0; i < agent->CurrentPlanSize; i++)
+				{
+					planInfo += $"\nAction {i + 1}: {plan[i].Path}";
+				}
+
+				Log.Info(planInfo);
+			}
+
+			currentGoal.Activate(frame, context);
+
+			if (debug == true)
+			{
+				Log.Info($"GOAP: Goal {currentGoal.Path} activated");
+			}
+
+			// Plan object is part of pooled GOAPAStar object
+			// so GOAPAStar needs to be returned after plan is no longer needed
+			Pool<GOAPAStar>.Return(aStar);
+		}
+
+		private static GOAPAction GetCurrentAction(Frame frame, GOAPAgent* agent)
+		{
+			if (agent->CurrentActionIndex < 0)
+				return null;
+
+			if (agent->LastProcessedActionIndex >= agent->CurrentActionIndex)
+				return null;
+
+			return frame.FindAsset<GOAPAction>(agent->Plan[agent->CurrentActionIndex].Id);
+		}
+
+		private static GOAPEntityContext GetContext(Frame frame, EntityRef entity)
+		{
+			var context = Pool<GOAPEntityContext>.Get();
+
+			context.Entity     = entity;
+			context.Agent      = frame.Unsafe.GetPointer<GOAPAgent>(entity);
+			context.Blackboard = frame.Has<AIBlackboardComponent>(entity) ? frame.Unsafe.GetPointer<AIBlackboardComponent>(entity) : null;
+			context.Root       = frame.FindAsset<GOAPRoot>(context.Agent->Root.Id);
+			context.Config     = frame.FindAsset<AIConfig>(context.Agent->Config.Id);
+
+			return context;
+		}
+	}
+
+	public unsafe class GOAPEntityContext
+	{
+		public EntityRef              Entity;
+		public GOAPAgent*             Agent;
+		public GOAPRoot               Root;
+		public AIConfig               Config;
+		public AIBlackboardComponent* Blackboard;
+	}
+}