quantum-space-buddies/QSB/ShipSync/TransformSync/ShipTransformSync.cs

using QSB.Syncs.Sectored.Rigidbodies;
using QSB.Utility;
using UnityEngine;

namespace QSB.ShipSync.TransformSync;

public class ShipTransformSync : SectoredRigidbodySync
{
	public static ShipTransformSync LocalInstance { get; private set; }

	public ShipThrusterVariableSyncer ThrusterVariableSyncer { get; private set; }

	private float _lastSetPositionTime;
	private const float ForcePositionAfterTime = 1;

	/// <summary>
	/// normally prints error when attached object is null.
	/// this overrides it so that doesn't happen, since the ship can be destroyed.
	/// </summary>
	protected override bool CheckValid()
		=> AttachedTransform
			&& base.CheckValid();

	protected override bool CheckReady() =>
		base.CheckReady() &&
		Locator.GetShipBody();

	public override void OnStartClient()
	{
		base.OnStartClient();
		LocalInstance = this;
	}

	protected override OWRigidbody InitAttachedRigidbody()
	{
		SectorDetector.Init(Locator.GetShipDetector().GetComponent<SectorDetector>());
		return Locator.GetShipBody();
	}

	protected override void Init()
	{
		base.Init();

		ThrusterVariableSyncer = this.GetRequiredComponent<ShipThrusterVariableSyncer>();
		ThrusterVariableSyncer.Init();

		ShipThrusterManager.CreateShipVFX();
	}

	/// Dont do base... this is a replacement!
	protected override void ApplyToAttached()
	{
		ApplyToSector();
		if (!ReferenceTransform)
		{
			return;
		}

		var targetPos = ReferenceTransform.FromRelPos(UseInterpolation ? SmoothPosition : transform.position);
		var targetRot = ReferenceTransform.FromRelRot(UseInterpolation ? SmoothRotation : transform.rotation);

		if (ShouldMovePlayer)
		{
			if (Time.unscaledTime >= _lastSetPositionTime + ForcePositionAfterTime)
			{
				_lastSetPositionTime = Time.unscaledTime;

				var playerBody = Locator.GetPlayerBody();
				var relPos = AttachedTransform.ToRelPos(playerBody.GetPosition());
				var relRot = AttachedTransform.ToRelRot(playerBody.GetRotation());

				SetPosition(AttachedRigidbody, targetPos);
				SetRotation(AttachedRigidbody, targetRot);

				playerBody.SetPosition(AttachedTransform.FromRelPos(relPos));
				playerBody.SetRotation(AttachedTransform.FromRelRot(relRot));
			}
		}
		else
		{
			SetPosition(AttachedRigidbody, targetPos);
			SetRotation(AttachedRigidbody, targetRot);
		}

		var targetVelocity = ReferenceRigidbody.FromRelVel(Velocity, targetPos);
		var targetAngularVelocity = ReferenceRigidbody.FromRelAngVel(AngularVelocity);

		SetVelocity(AttachedRigidbody, targetVelocity);
		AttachedRigidbody.SetAngularVelocity(targetAngularVelocity);
	}

	#region copied from OWRigidbody

	private static void SetPosition(OWRigidbody @this, Vector3 worldPosition)
	{
		@this._transform.position = worldPosition;
	}

	private static void SetRotation(OWRigidbody @this, Quaternion rotation)
	{
		@this._transform.rotation = rotation;
	}

	private static void SetVelocity(OWRigidbody @this, Vector3 newVelocity)
	{
		if (@this.RunningKinematicSimulation())
		{
			@this._kinematicRigidbody.velocity = newVelocity + Locator.GetCenterOfTheUniverse().GetStaticFrameVelocity_Internal();
		}
		else
		{
			@this._rigidbody.velocity = newVelocity + Locator.GetCenterOfTheUniverse().GetStaticFrameVelocity_Internal();
		}
		@this._lastVelocity = @this._currentVelocity;
		@this._currentVelocity = newVelocity;
	}

	#endregion


	private bool ShouldMovePlayer => Vector3.Distance(AttachedTransform.position, Locator.GetPlayerBody().GetPosition()) < 20;
	protected override bool UseInterpolation => !ShouldMovePlayer;
}