Weapons/PhysGun/Physgun.cs

The physgun weapon. Raycasts for rigidbodies, grabs them with a physics hold joint, pulls and launches them, freezes and unfreezes bodies, and syncs the grab state, hold target, sounds and beam between owner, host and proxies.

using Sandbox.Physics;
using Sandbox.Rendering;

[Title( "#weapon.name.physgun" )]
public partial class Physgun : Local.IPlayerEvents
{
	public Physgun()
	{
		// Tools don't use ammo (the engine default is on, which would show an ammo indicator).
		UsesAmmo = false;
	}

	[Property, RequireComponent] public HighlightOutline BeamHighlight { get; set; }

	[Property, Group( "Sound" )] SoundEvent ReleasedSound { get; set; }
	[Property, Group( "Sound" )] SoundEvent ButtonInSound { get; set; }
	[Property, Group( "Sound" )] SoundEvent ButtonOutSound { get; set; }
	[Property, Group( "Sound" )] SoundEvent GravityDrySound { get; set; }
	[Property, Group( "Sound" )] SoundEvent GravityLaunchSound { get; set; }
	[Property, Group( "Sound" )] SoundEvent GravityDropSound { get; set; }
	[Property, Group( "Sound" )] SoundEvent GravityPullSound { get; set; }
	[Property, Group( "Sound" )] SoundEvent GravityHoldSound { get; set; }
	[Property, Group( "Sound" )] SoundEvent GravityLookOpenSound { get; set; }
	[Property, Group( "Sound" )] SoundEvent GravityLookCloseSound { get; set; }
	[Property, Group( "Sound" )] float GravityLookDropCooldown { get; set; } = 0.5f;

	SoundHandle _gravityHoldSound;
	SoundHandle _gravityLookOpenSound;
	SoundHandle _gravityLookCloseSound;
	bool _clawsOpen;
	bool _clawSoundsSuppressed;
	TimeUntil _gravityLookCooldown;
	TimeUntil _clawOpenSoundCooldown;
	TimeUntil _clawCloseSoundCooldown;
	const float ClawSoundMinInterval = 2f;
	float ClawOpenAmount => _state.Active ? 1f : CanGravityGrabHovered() ? 0.5f : 0f;

	bool CanGravityGrabHovered()
	{
		if ( !_stateHovered.IsValid() ) return false;
		var body = _stateHovered.Body;
		if ( !body.IsValid() || !body.MotionEnabled ) return false;

		var eyePosition = CurrentAimTransform.Position;
		return FindClosestPoint( body, eyePosition ).Distance( eyePosition ) <= PullDistance;
	}

	void UpdateClawSounds()
	{
		// Attack-driven claw movement has its own sounds. Only track idle gravity targeting here.
		if ( _state.Active || _state.Pulling || _stateHovered.Pulling )
		{
			_gravityLookOpenSound?.Stop( 0.2f );
			_gravityLookOpenSound = null;
			_gravityLookCloseSound?.Stop( 0.2f );
			_gravityLookCloseSound = null;
			_clawSoundsSuppressed = true;
			return;
		}

		var open = CanGravityGrabHovered();
		if ( _gravityLookCooldown > 0 )
		{
			_clawsOpen = open;
			return;
		}

		if ( _clawSoundsSuppressed )
		{
			_clawSoundsSuppressed = false;
			_clawsOpen = open;
			return;
		}

		if ( open == _clawsOpen ) return;

		_clawsOpen = open;
		if ( open )
		{
			if ( _clawOpenSoundCooldown > 0 ) return;
			_clawOpenSoundCooldown = ClawSoundMinInterval;
			_gravityLookOpenSound?.Stop( 0.2f );
			_gravityLookOpenSound = GameObject.PlaySound( GravityLookOpenSound );
		}
		else
		{
			if ( _clawCloseSoundCooldown > 0 ) return;
			_clawCloseSoundCooldown = ClawSoundMinInterval;
			_gravityLookCloseSound?.Stop( 0.2f );
			_gravityLookCloseSound = GameObject.PlaySound( GravityLookCloseSound );
		}
	}

	[Rpc.Broadcast]
	void PlayGravityShotSound( bool pulling )
	{
		GameObject.PlaySound( pulling ? GravityPullSound : GravityDrySound );
	}

	[Rpc.Broadcast]
	void PlayGravityLaunchSound()
	{
		GameObject.PlaySound( GravityLaunchSound );
	}

	[Rpc.Broadcast]
	void PlayGravityDropSound()
	{
		_gravityLookCooldown = GravityLookDropCooldown;
		GameObject.PlaySound( GravityDropSound );
	}

	[Rpc.Broadcast]
	void PlayGravityLockSound()
	{
		GameObject.PlaySound( GravityDropSound );
	}

	/// <summary>
	/// The gravity hold loop plays at <see cref="HoldSoundFarPitch"/> when the object is this far away or further.
	/// </summary>
	const float HoldSoundFarDistance = 1024f;

	/// <summary>
	/// The gravity hold loop plays at full pitch when the object is this close or closer.
	/// </summary>
	const float HoldSoundNearDistance = 128f;

	const float HoldSoundFarPitch = 0.5f;

	void UpdateGravityHoldSound()
	{
		// Plays while holding an object, and while pulling one in
		var state = _state.Active && _state.Pulling ? _state : _stateHovered;

		if ( state.Pulling && state.IsValid() && state.Body.IsValid() && state.Body.MotionEnabled )
		{
			var eye = CurrentAimTransform.Position;
			var distance = FindClosestPoint( state.Body, eye ).Distance( eye );

			_gravityHoldSound ??= GameObject.PlaySound( GravityHoldSound );
			_gravityHoldSound?.Position = GetMuzzleTransform().Position;
			_gravityHoldSound?.Pitch = MathX.Remap( distance, HoldSoundFarDistance, HoldSoundNearDistance, HoldSoundFarPitch, 1f );
		}
		else
		{
			_gravityHoldSound?.Stop( 0.2f );
			_gravityHoldSound = null;
		}
	}

	[Property] public float Range { get; set; } = 8196f;

	public record struct GrabState
	{
		public bool Active { get; set; }
		public bool Pulling { get; set; }
		public GameObject GameObject { get; set; }
		public Vector3 LocalOffset { get; set; }
		public Vector3 LocalNormal { get; set; }
		public Rotation GrabOffset { get; set; }
		public float GrabDistance { get; set; }

		/// <summary>
		/// Gravity pulls only: the pull cone's apex, as a world-space offset from the aim position.
		/// </summary>
		public Vector3 PullApex { get; set; }

		/// <summary>
		/// Gravity pulls only: how strongly the object is pulled, depending on how well we aim at it.
		/// </summary>
		public float PullStrength { get; set; }

		public readonly Vector3 EndPoint
		{
			get
			{
				if ( !GameObject.IsValid() ) return LocalOffset;
				return GameObject.WorldTransform.PointToWorld( LocalOffset );
			}
		}

		/// <summary>
		/// <see cref="EndPoint"/> on the physics body. On a proxy the body chases the latest network transform
		/// while the object is drawn interpolated, so measure the body against this, not the drawn point.
		/// </summary>
		public readonly Vector3 BodyPoint
		{
			get
			{
				var physicsBody = Body?.PhysicsBody;
				if ( !physicsBody.IsValid() ) return EndPoint;
				return physicsBody.Transform.WithScale( GameObject.WorldScale ).PointToWorld( LocalOffset );
			}
		}

		public readonly Vector3 EndNormal
		{
			get
			{
				if ( !GameObject.IsValid() ) return LocalNormal;
				return GameObject.WorldTransform.NormalToWorld( LocalNormal );
			}
		}

		public readonly bool IsValid() => GameObject.IsValid();

		public readonly Rigidbody Body => GameObject?.GetComponent<Rigidbody>();

		public override readonly int GetHashCode()
		{
			var hash = new HashCode();
			hash.Add( Active );
			hash.Add( Pulling );
			hash.Add( GameObject );
			hash.Add( LocalOffset );
			hash.Add( LocalNormal );
			hash.Add( GrabOffset );
			hash.Add( GrabDistance );
			hash.Add( PullApex );
			hash.Add( PullStrength );
			return hash.ToHashCode();
		}
	}

	[Sync] public GrabState _state { get; set; } = default;

	[Sync] public GrabState _stateHovered { get; set; } = default;

	// Where the holder wants the body, from their own aim, so the host doesn't steer by the interpolated one
	[Sync( SyncFlags.Interpolate )] public Transform _holdTarget { get; set; }
	[Sync] public int _holdTargetId { get; set; }
	[Sync( SyncFlags.Interpolate )] public float _holdTargetIdLerped { get; set; }

	GameObject _holdTargetObject;
	bool _holdTargetCursorAim;
	Transform _holdStart;

	Transform _lastAimTransform;
	Transform CurrentAimTransform => HasOwner ? OwnerAimTransform : _lastAimTransform;

	bool IsCursorDragging => !IsProxy && InspectCursor.IsDragging;
	bool _cursorAim;

	Transform OwnerAimTransform
	{
		get
		{
			if ( IsProxy || !_cursorAim ) return Owner.EyeTransform;

			var ray = InspectCursor.DragRay;
			return new Transform( ray.Position, Rotation.LookAt( ray.Forward ) );
		}
	}

	Rotation FrameRotation => HasOwner ? Owner.EyeTransform.Rotation : _lastAimTransform.Rotation;

	bool _preventReselect = false;

	void Local.IPlayerEvents.OnMove( ref bool allowMovement )
	{
		if ( _isSpinning ) allowMovement = false;
	}

	void Local.IPlayerEvents.OnCarry( PlayerCarryEvent e )
	{
		if ( _state.IsValid() || _stateHovered.Pulling ) e.Cancelled = true;
	}

	bool _isSpinning;
	readonly HoldRotation _rotation = new();

	bool _launched;

	/// <summary>
	/// The force applied to pull objects to us.
	/// </summary>
	static float PullForce => 1000.0f;

	/// <summary>
	/// The force applied when launching grabbed objects.
	/// </summary>
	static float LaunchForce => 2000.0f;

	/// <summary>
	/// The distance at which we'll grab an object when pulling it towards us.
	/// </summary>
	static float PullDistance => 200.0f;

	/// <summary>
	/// How quickly W/S moves a held object while rotate mode is active.
	/// </summary>
	static float KeyboardMoveSpeed => 240.0f;

	public override void OnCameraMove( Player player, ref Angles angles )
	{
		base.OnCameraMove( player, ref angles );

		if ( _state.IsValid() && _isSpinning )
		{
			angles = default;
		}
	}

	bool _beamPlacedThisFrame;

	protected override void PlaceViewModel( CameraComponent camera, in CameraView view )
	{
		base.PlaceViewModel( camera, view );

		UpdateBeamState();
		_beamPlacedThisFrame = true;
	}

	protected override void OnPreRender()
	{
		base.OnPreRender();
		UpdateGravityHoldSound();
		UpdateClawSounds();

		if ( _beamPlacedThisFrame )
		{
			_beamPlacedThisFrame = false;
			return;
		}

		UpdateBeamState();
	}

	void UpdateBeamState()
	{
		if ( _state.Active && !_state.Pulling )
		{
			var muzzle = HasOwner ? GetMuzzleTransform() : CurrentAimTransform;
			var end = _state.EndPoint;
			var endNormal = _stateHovered.EndNormal;

			if ( !_state.IsValid() && HasOwner && !IsProxy )
			{
				var aim = CurrentAimTransform;
				var tr = Scene.Trace.Ray( aim.Position, aim.Position + aim.Forward * Range )
					.IgnoreGameObjectHierarchy( GameObject.Root )
					.Run();

				end = tr.EndPosition;
				endNormal = tr.Normal;
			}

			UpdateBeam( muzzle, CurrentAimTransform.Forward, end, endNormal, _state.IsValid() );
		}
		else
		{
			CloseBeam();
		}
	}

	protected override void OnControl()
	{
		ControlGrab();

		// After the grab changes, so they go out together
		UpdateHoldTarget();
	}

	void ControlGrab()
	{
		var player = Owner;

		_lastAimTransform = AimTransform;

		UpdateViewmodelScreen();
		UpdateScreenGraph();

		if ( Scene.TimeScale == 0 )
			return;

		if ( Input.Pressed( "use" ) && _state.IsValid() )
		{
			ViewModel?.PlaySound( ButtonInSound );
		}
		else if ( Input.Released( "use" ) && _state.IsValid() )
		{
			ViewModel?.PlaySound( ButtonOutSound );
		}

		var spinMove = Vector3.Zero;
		_isSpinning = Input.Down( "use" ) && _state.Active && _state.IsValid();
		if ( _isSpinning )
		{
			spinMove = Input.AnalogMove;
			player.Controller.WishVelocity = Vector3.Zero;
			Input.Clear( "use" );
		}

		_rotation.UpdateSnapping();

		var isPulling = Input.Down( "attack2" ) && !_preventReselect;
		var primaryDown = Input.Down( "attack1" ) || IsCursorDragging;
		var cursorFreeze = InspectCursor.ConsumeFreeze();
		if ( !_state.IsValid() ) _cursorAim = IsCursorDragging;
		var aim = CurrentAimTransform;

		ViewModel?.RunEvent<ViewModel>( _updateViewModel ??= UpdateViewModel );

		var pullLock = _stateHovered;
		_stateHovered = default;

		if ( _state.IsValid() )
		{
			if ( Input.Pressed( "reload" ) )
			{
				UnfreezeAll( _state.Body );
				Input.Clear( "reload" );
			}

			if ( _state.Pulling )
			{
				if ( Input.Pressed( "attack1" ) )
				{
					var force = player.EyeTransform.Rotation.Forward * LaunchForce;
					Launch( _state.Body, force );
					PlayGravityLaunchSound();

					_state = default;
					_isSpinning = false;
					_preventReselect = true;
				}
				else if ( Input.Pressed( "attack2" ) )
				{
					PlayGravityDropSound();
					_state = default;
					_isSpinning = false;
					_preventReselect = true;
				}
			}
			else
			{
				if ( !primaryDown )
				{
					_state = default;
					_preventReselect = true;
					ViewModel?.PlaySound( ReleasedSound );
					return;
				}

				if ( Input.Down( "attack2" ) || cursorFreeze )
				{
					Freeze( _state.Body );
					_state = default;
					_preventReselect = true;
					ViewModel?.PlaySound( ReleasedSound );
					return;
				}

				if ( !Input.MouseWheel.IsNearZeroLength )
				{
					var state = _state;
					state.GrabDistance += Input.MouseWheel.y * 20.0f;
					state.GrabDistance = MathF.Max( 0.0f, state.GrabDistance );

					_state = default;
					_state = state;

					// stop processing this so inventory doesn't change
					Sandbox.Inventory.ConsumeMouseWheel();
				}
			}

			if ( _isSpinning )
			{
				var move = spinMove;
				var state = _state;

				// Only beam grabs allow W/S to adjust the holding distance.
				if ( !state.Pulling )
				{
					state.GrabDistance += move.x * KeyboardMoveSpeed * Time.Delta;
					state.GrabDistance = MathF.Max( 0.0f, state.GrabDistance );
				}

				// Gravity holds use W/S to pitch around the viewer's right axis.
				state.GrabOffset = _rotation.Rotate( HoldFrame, move, state.Pulling );

				// State needs to reset for sync to detect a change, bug or how it's meant to work?
				_state = default;
				_state = state;
			}

			return;
		}
		else
		{
			_state = default;
		}

		if ( _preventReselect )
		{
			if ( !primaryDown && !Input.Down( "attack2" ) )
				_preventReselect = false;

			return;
		}

		FindGrabbedBody( out var sh, aim, isPulling );
		if ( isPulling ) sh = UpdatePullLock( pullLock, sh, aim );
		_stateHovered = sh;

		if ( isPulling && Input.Pressed( "attack2" ) )
			PlayGravityShotSound( sh.IsValid() && sh.Body.IsValid() && sh.Body.MotionEnabled );

		if ( sh.IsValid() && sh.Pulling && sh.Body.MotionEnabled )
		{
			var eyePosition = aim.Position;
			var closest = FindClosestPoint( sh.Body, eyePosition );
			var distance = closest.Distance( eyePosition );

			if ( distance <= PullDistance )
			{
				_state = sh with { Active = true, Pulling = true, };
			}
		}

		if ( _state.Pulling || _stateHovered.Pulling )
			return;

		if ( primaryDown )
		{
			ViewModel?.RunEvent<ViewModel>( x => x.OnAttack() );

			var muzzle = WeaponModel?.MuzzleGameObject?.WorldTransform ?? player.EyeTransform;

			_state = _stateHovered with { Active = true, Pulling = false };

			if ( _state.GameObject is { } go )
			{
				go.Root.RunEvent<IPhysgunEvent>( x => x.OnPhysgunPickup() );
			}

			if ( _state.IsValid() )
			{
				Unfreeze( _state.Body );
			}
		}
		else if ( Input.Released( "attack1" ) )
		{
			ViewModel?.PlaySound( ReleasedSound );
		}
		else if ( Input.Pressed( "reload" ) )
		{
			if ( _stateHovered.IsValid() )
			{
				UnfreezeAll( _stateHovered.Body );
			}
		}
		else
		{
			_state = default;
			_preventReselect = false;
		}
	}

	private bool _primaryControlDown;
	private bool _secondaryControlDown;

	protected override void OnPrimaryPressed()
	{
		if ( !_state.IsValid() || !_state.Pulling ) return;

		var force = AimTransform.Rotation.Forward * LaunchForce;
		Launch( _state.Body, force );
		PlayGravityLaunchSound();
		_state = default;
		_preventReselect = true;
	}

	protected override void OnPrimaryDown()
	{
		_primaryControlDown = true;

		if ( _state.IsValid() )
			return;

		if ( ConsumeReselectBlock() ) return;
		UpdateGrab();
	}

	protected override void OnPrimaryReleased()
	{
		_primaryControlDown = false;

		if ( _state.IsValid() )
		{
			if ( !_state.Pulling )
			{
				_state = default;
				_preventReselect = true;
				GameObject.PlaySound( ReleasedSound );
			}

			return;
		}

		if ( ConsumeReselectBlock() ) return;

		if ( _secondaryControlDown )
		{
			UpdateGrab();
		}
		else
		{
			_stateHovered = default;
			GameObject.PlaySound( ReleasedSound );
		}
	}

	protected override void OnSecondaryPressed()
	{
		if ( !_state.IsValid() )
		{
			if ( _preventReselect ) return;
			var aim = AimTransform;
			FindGrabbedBody( out var sh, aim, true );
			PlayGravityShotSound( sh.IsValid() && sh.Body.IsValid() && sh.Body.MotionEnabled );
			return;
		}

		if ( !_state.Pulling ) return;

		PlayGravityDropSound();
		_state = default;
		_preventReselect = true;
	}

	protected override void OnSecondaryDown()
	{
		_secondaryControlDown = true;

		if ( _state.IsValid() )
			return;

		if ( ConsumeReselectBlock() ) return;
		UpdateGrab();
	}

	protected override void OnSecondaryReleased()
	{
		_secondaryControlDown = false;

		if ( _state.IsValid() || ConsumeReselectBlock() ) return;

		if ( _primaryControlDown )
			UpdateGrab();
		else
			_stateHovered = default;
	}

	private bool ConsumeReselectBlock()
	{
		if ( !_preventReselect ) return false;
		if ( !_primaryControlDown && !_secondaryControlDown ) _preventReselect = false;
		return true;
	}

	private void AdjustGrabDistance( float amount )
	{
		if ( HasOwner || !Networking.IsHost || !_state.IsValid() || _state.Pulling ) return;

		var state = _state;
		state.GrabDistance = MathF.Max( 0f, state.GrabDistance + amount );
		_state = default;
		_state = state;
	}

	/// <summary>
	/// Increases the grab distance using a connected signal.
	/// </summary>
	[SignalInput( Id = nameof( ExtendInput ) ), Description( "#weapon.setting.extend.description" )]
	public void ExtendSignal( float amount ) => AdjustGrabDistance( amount * 200f * Time.Delta );

	/// <summary>
	/// Decreases the grab distance using a connected signal.
	/// </summary>
	[SignalInput( Id = nameof( RetractInput ) ), Description( "#weapon.setting.retract.description" )]
	public void RetractSignal( float amount ) => AdjustGrabDistance( -amount * 200f * Time.Delta );

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

		if ( ExtendInput.Down() ) AdjustGrabDistance( 200f * Time.Delta );
		if ( RetractInput.Down() ) AdjustGrabDistance( -200f * Time.Delta );
	}

	private void UpdateGrab()
	{
		var aim = AimTransform;
		_lastAimTransform = aim;

		var pullLock = _stateHovered;
		_stateHovered = default;
		FindGrabbedBody( out var sh, aim, _secondaryControlDown );
		if ( _secondaryControlDown ) sh = UpdatePullLock( pullLock, sh, aim );
		_stateHovered = sh;

		if ( sh.IsValid() && sh.Pulling && sh.Body.MotionEnabled )
		{
			var closest = FindClosestPoint( sh.Body, aim.Position );
			if ( closest.Distance( aim.Position ) <= PullDistance )
			{
				_state = sh with { Active = true, Pulling = true };
			}
		}

		if ( _state.Pulling || _stateHovered.Pulling )
			return;

		if ( _primaryControlDown )
		{
			_state = _stateHovered with { Active = true, Pulling = false };

			if ( _state.GameObject is { } go )
			{
				go.Root.RunEvent<IPhysgunEvent>( x => x.OnPhysgunPickup() );
			}

			if ( _state.IsValid() )
				Unfreeze( _state.Body );
		}
		else
		{
			_state = default;
		}
	}

	Action<ViewModel> _updateViewModel;

	private void UpdateViewModel( ViewModel model )
	{
		model.IsAttacking = _state.Active;
		model.Renderer?.Set( "stylus", ClawOpenAmount );
		model.Renderer?.Set( "b_button", _isSpinning );
		model.Renderer?.Set( "brake", _state.Active || _state.Pulling || _stateHovered.Pulling ? 1 : 0 );
	}

	readonly PhysicsHold _hold = new();

	/// <summary>
	/// The object our joint is moving
	/// </summary>
	GameObject _held;

	/// <summary>
	/// Tells the object we were moving that we let go of it
	/// </summary>
	void DropHeld()
	{
		var held = _held;
		_held = null;

		if ( !held.IsValid() ) return;

		held.Root.RunEvent<IPhysgunEvent>( x => x.OnPhysgunDrop() );
	}

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

		_hold.Release();
		DropHeld();
		CloseBeam();
		_gravityHoldSound?.Stop( 0.2f );
		_gravityHoldSound = null;

		_state = default;
		_gravityLookOpenSound?.Stop( 0.2f );
		_gravityLookOpenSound = null;
		_gravityLookCloseSound?.Stop( 0.2f );
		_gravityLookCloseSound = null;
		_clawsOpen = false;
		_clawSoundsSuppressed = false;
		_gravityLookCooldown = 0;
		_stateHovered = default;
		_launched = default;
		_primaryControlDown = false;
		_secondaryControlDown = false;
		_isSpinning = false;
		_cursorAim = false;
	}

	// Set every frame, a value from fixed update would be sent stamped with a later frame's time.
	// Also while hovering, so the host's interpolated target never starts a grab from where the last one let go.
	void UpdateHoldTarget()
	{
		var state = _state.Body.IsValid() ? _state : _stateHovered;
		var target = state.Body.IsValid() ? state.GameObject : null;
		_holdTarget = target.IsValid() ? GetHoldTarget( state ) : CurrentAimTransform;

		if ( target == _holdTargetObject && _cursorAim == _holdTargetCursorAim ) return;

		_holdTargetObject = target;
		_holdTargetCursorAim = _cursorAim;
		_holdTargetId++;
		_holdTargetIdLerped = _holdTargetId;
	}

	/// <summary>
	/// The holder's target once the interpolated one is all for what they hold, until then where we grabbed it.
	/// </summary>
	Transform GetProxyHoldTarget()
	{
		var caughtUp = _holdTargetIdLerped.AlmostEqual( _holdTargetId );
		return ClampToRange( caughtUp ? _holdTarget : _holdStart );
	}

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

		// switched straight to another object, the joint still holds the old one
		if ( _held.IsValid() && _held != _state.GameObject )
		{
			_hold.Release();
			DropHeld();
		}

		if ( !CanMoveFor( _state ) )
		{
			_hold.Release();
			DropHeld();

			if ( _stateHovered.Pulling && CanMoveFor( _stateHovered ) )
				ApplyPullForce( _stateHovered );

			_launched = false;

			return;
		}

		// If we just launched, don't add a joint until state has let go.
		if ( _launched ) return;

		if ( !_hold.IsHolding )
			_holdStart = new Transform( _state.EndPoint, _state.Body.WorldRotation );

		_held = _state.GameObject;
		DamageBlame.Blame( _held, Owner );
		_hold.Hold( _state.Body, _state.EndPoint );
		_hold.Move( IsProxy ? GetProxyHoldTarget() : GetHoldTarget() );
	}

	/// <summary>
	/// The frame <see cref="GrabState.GrabOffset"/> is relative to: the full aim rotation for gravity
	/// holds, only the stabilized yaw for beam grabs.
	/// </summary>
	Rotation HoldFrame => _state.Pulling ? CurrentAimTransform.Rotation : PhysicsHold.Stabilize( FrameRotation );

	Transform GetHoldTarget() => GetHoldTarget( _state );

	Transform GetHoldTarget( in GrabState state )
	{
		var eyeTransform = CurrentAimTransform;
		var point = state.Body.IsProxy ? state.BodyPoint : state.EndPoint;
		var grabDistance = PhysicsHold.ClampGrabDistance( state.Body, point, eyeTransform, state.GrabDistance );
		var targetPosition = eyeTransform.Position + eyeTransform.Rotation.Forward * grabDistance;
		var frame = state.Pulling ? eyeTransform.Rotation : PhysicsHold.Stabilize( FrameRotation );
		return new Transform( targetPosition, frame * state.GrabOffset );
	}

	// The holder sends the target, keep it within reach of where we see them
	Transform ClampToRange( Transform target )
	{
		var eye = CurrentAimTransform.Position;
		return target.WithPosition( eye + (target.Position - eye).ClampLength( Range ) );
	}

	/// <summary>
	/// When true, the physgun aims where the seated player's camera looks.
	/// </summary>
	[Property, ClientEditable, Sync, Title( "#weapon.setting.camera_aim" ), Description( "#weapon.setting.camera_aim.description" )]
	public bool CanAim { get; set; } = true;

	public override bool IsTargetedAim => CanAim;

	Transform AimTransform
	{
		get
		{
			var ray = AimRay;
			return new Transform( ray.Position, Rotation.LookAt( ray.Forward ) );
		}
	}

	bool CanMove( GrabState state )
	{
		if ( !state.IsValid() ) return false;
		if ( !state.Body.IsValid() ) return false;

		// Only move the body if we own it.
		if ( state.Body.IsProxy ) return false;

		// Only move the body if it's dynamic.
		if ( !state.Body.MotionEnabled ) return false;
		if ( !state.Body.PhysicsBody.IsValid() ) return false;

		return true;
	}

	/// <summary>
	/// Ask the object if it allows being grabbed (anything can reject via IPhysgunEvent)
	/// </summary>
	bool AllowsGrab( GameObject go )
	{
		var grabEvent = new IPhysgunEvent.GrabEvent { Grabber = Network.Owner };
		go.Root.RunEvent<IPhysgunEvent>( x => x.OnPhysgunGrab( grabEvent ) );
		return !grabEvent.Cancelled;
	}

	/// <summary>
	/// Is this physgun holding <paramref name="root"/> or pulling it in? The grab is synced, so this works everywhere.
	/// </summary>
	public bool IsGrabbing( GameObject root )
	{
		return Grabs( _state ) || (_stateHovered.Pulling && Grabs( _stateHovered ));

		bool Grabs( GrabState state ) => (state.Active || state.Pulling) && state.GameObject?.Root == root;
	}

	/// <summary>
	/// The holder picks what to grab on their machine, so check it again here before moving it for them.
	/// </summary>
	bool CanMoveFor( in GrabState state ) => CanMove( state ) && (!IsProxy || AllowsGrab( state.GameObject ));

	bool FindGrabbedBody( out GrabState state, Transform aim, bool isPulling )
	{
		state = default;

		var tr = Scene.Trace.Ray( aim.Position, aim.Position + aim.Forward * Range )
			.IgnoreGameObjectHierarchy( GameObject.Root )
			.Run();

		state.LocalOffset = tr.EndPosition;
		state.LocalNormal = tr.Normal;
		state.Pulling = isPulling;

		var rb = tr.Hit && tr.Body is not null ? tr.Component as Rigidbody : null;

		if ( isPulling )
		{
			if ( !CanPull( rb ) )
				rb = FindPullTarget( aim, tr ) ?? rb;

			if ( GetRagdollRoot( rb ) is { } root )
				rb = root;
		}

		if ( !rb.IsValid() || !rb.PhysicsBody.IsValid() ) return false;

		var physicsBody = rb.PhysicsBody;
		var go = physicsBody.GameObject;
		if ( !go.IsValid() || go.IsDestroyed ) return false;

		if ( !AllowsGrab( go ) ) return false;

		// Trace hits physics, convert to local using scaled physics transform.
		var bodyTransform = physicsBody.Transform.WithScale( go.WorldScale );

		state.GameObject = go;
		state.LocalNormal = bodyTransform.NormalToLocal( tr.Normal );

		if ( isPulling )
		{
			// Scale is built into mass center, remove it.
			var bodyScale = new Transform( Vector3.Zero, Rotation.Identity, bodyTransform.Scale );
			state.LocalOffset = bodyScale.PointToLocal( physicsBody.LocalMassCenter );
			state.GrabDistance = 0;
			state.GrabOffset = aim.Rotation.Inverse * bodyTransform.Rotation;
		}
		else
		{
			state.LocalOffset = bodyTransform.PointToLocal( tr.HitPosition );
			state.GrabDistance = Vector3.DistanceBetween( aim.Position, tr.HitPosition );
			state.GrabDistance = PhysicsHold.ClampGrabDistance( state.Body, tr.HitPosition, aim, state.GrabDistance );
			state.GrabOffset = PhysicsHold.Stabilize( FrameRotation ).Inverse * bodyTransform.Rotation;
		}

		_rotation.Reset( state.GrabOffset );

		return true;
	}

	[Rpc.Broadcast( NetFlags.OwnerOnly )]
	void Freeze( Rigidbody body )
	{
		if ( !body.IsValid() ) return;

		var go = body.GameObject;
		if ( go.Tags.Has( "npc" ) )
			return;

		FreezeEffect.Play( go, true, IsProxy ? null : [go] );

		if ( body.IsProxy ) return;

		if ( Networking.IsHost && AllowsGrab( go ) )
		{
			body.MotionEnabled = false;
		}
	}

	[Rpc.Host( NetFlags.OwnerOnly )]
	void Unfreeze( Rigidbody body ) => UnfreezeBody( body );

	void UnfreezeBody( Rigidbody body )
	{
		if ( !body.IsValid() ) return;
		if ( body.IsProxy ) return;
		if ( !AllowsGrab( body.GameObject ) ) return;

		body.MotionEnabled = true;
	}

	[Rpc.Broadcast( NetFlags.OwnerOnly )]
	void UnfreezeAll( Rigidbody body )
	{
		if ( !body.IsValid() ) return;

		var bodies = new HashSet<Rigidbody>();
		if ( !IsProxy || !body.IsProxy )
			PhysicsHold.GetConnectedBodies( body.GameObject, bodies );

		FreezeEffect.Play( body.GameObject, false, IsProxy ? null : bodies.Select( x => x.GameObject ) );

		if ( IsProxy && body.IsProxy ) return;

		if ( !IsProxy )
		{
			var count = bodies.Select( x => x.GameObject.Root ).Distinct().Count();
			var phrase = Game.Language.GetPhrase( "physgun.unfrozen", new() { { "count", count.ToString() } } );
			Sandbox.UI.Notices.AddNotice( "ac_unit", Color.Cyan, phrase );
		}

		if ( body.IsProxy || !Networking.IsHost ) return;

		foreach ( var rb in bodies )
		{
			UnfreezeBody( rb );
		}

		var models = bodies
			.Select( x => x.Components.GetInAncestorsOrSelf<ModelPhysics>() )
			.Where( x => x.IsValid() )
			.Distinct();

		foreach ( var mp in models )
		{
			UnfreezeModelPhysics( mp );
		}
	}

	void UnfreezeModelPhysics( ModelPhysics modelPhysics )
	{
		if ( !modelPhysics.IsValid() ) return;
		if ( modelPhysics.IsProxy ) return;
		if ( !AllowsGrab( modelPhysics.GameObject ) ) return;

		modelPhysics.MotionEnabled = true;
	}

	[Rpc.Host( NetFlags.OwnerOnly )]
	void Launch( Rigidbody body, Vector3 force )
	{
		if ( !body.IsValid() ) return;
		if ( body.IsProxy ) return;
		if ( !AllowsGrab( body.GameObject ) ) return;

		// We already launched.
		if ( _launched ) return;

		_hold.Release();
		DamageBlame.Blame( body.GameObject, Owner );

		var mass = body.Mass;
		body.ApplyImpulse( force.Normal * (mass * force.Length) );
		body.PhysicsBody?.ApplyAngularImpulse( Vector3.Random * (mass * force.Length) );

		_launched = true;
	}
}