SOLID Principles - Dependency Injection (not dependency inversion)

AiInput.cs

using UnityEngine;

public class AiInput : IShipInput
{
    public float Rotation { get; private set;}
    public float Thrust { get; private set;}
    
    public void ReadInput()
    {
        Rotation = Random.Range(-1f, 1f);
        Thrust = Random.Range(-1f, 1f);
    }
}

ControllerInput.cs

using UnityEngine;

public class ControllerInput : IShipInput
{
    public float Rotation { get; private set;}
    public float Thrust { get; private set;}
    
    public void ReadInput()
    {
        Rotation = Input.GetAxis("Horizontal");
        Thrust = Input.GetAxis("Vertical");
    }
    
    
}

IShipInput.cs

public interface IShipInput
{
    void ReadInput();
    float Rotation { get; }
    float Thrust { get; }
}

Ship.cs

using UnityEngine;

// From here to above codes, we are using a better approach, using Dependency Injection
public class Ship : MonoBehaviour
{
    [SerializeField] private ShipSettings shipSettings;
    
    private IShipInput shipInput;
    private ShipMotor shipMotor;
    
    private void Awake()
    {
        shipInput = shipSettings.UseAi ? new AiInput() as IShipInput : new ControllerInput();
        // ShipMotor isn't a MonoBehaviour, it doesn't need to be
        shipMotor = new ShipMotor(shipInput, transform, shipSettings);
    }
    
    private void Update()
    {
        shipInput.ReadInput();
        shipMotor.Tick();
    }
}

ShipMotor.cs

using UnityEngine;

public class ShipMotor
{
    private readonly IShipInput shipInput;
    private readonly Transform transformToMove;
    private readonly ShipSettings shipSettings;

    public ShipMotor(IShipInput shipInput, Transform transformToMove, ShipSettings shipSettings)
    {
        this.shipInput = shipInput;
        this.transformToMove = transformToMove;
        this.shipSettings = shipSettings;
    }
    
    public void Tick()
    {
        transformToMove.Rotate(Vector3.up * shipInput.Rotation * Time.deltaTime * shipSettings.TurnSpeed);
        tranformToMove.position += transformToMove.forward * shipInput.Thrust * Time.deltaTime * shipSettings.MoveSpeed;
    }
}

ShipMotorOriginal.cs

using UnityEngine;

public class ShipMotorOriginal : MonoBehaviour
{
    [SerializeField] private float turnSpeed = 15f;
    [SerializeField] private float moveSpeed = 10f;
    
    private void Update()
    {
        // We are handling input, so it breaks the single responsibility principle
        float rotation = Input.GetAxis("Horizontal");
        float thrust = Input.GetAxis("Vertical");
        transform.Rotate(Vector3.up * rotation * Time.deltaTime * turnSpeed);
        transform.position += transform.forward * thrust * Time.deltaTime * moveSpeed;
    }
}

ShipMotorSplit.cs

using UnityEngine;

public class ShipMotorSplit : MonoBehaviour
{
    [SerializeField] private float turnSpeed = 15f;
    [SerializeField] private float moveSpeed = 10f;
    
    private ShipInputSplit shipInput;
    
    private void Awake()
    {
        // we can have a SetInput() method, so swap the input to use with AI or Network
        shipInput = GetComponent<ShipInputSplit>();
    }
    
    private void Update()
    {        
        float rotation = shipInput.Rotation;
        float thrust = shipInput.Thrust;
        transform.Rotate(Vector3.up * rotation * Time.deltaTime * turnSpeed);
        transform.position += transform.forward * thrust * Time.deltaTime * moveSpeed;
    }
}

ShipSettings.cs

using UnityEngine;

[CreateAssetMenu(menuName = "Ship/Settings", fileName = "ShipData")]
public class ShipSettings : ScriptableObject
{
    [SerializeField] private float turnSpeed = 25f;
    [SerializeField] private float moveSpeed = 10f;
    [SerializeField] private bool useAi = false;
    
    public float TurnSpeed { get { return turnSpeed; } }
    public float MoveSpeed { get { return moveSpeed; } }
    public bool UseAi { get { return useAi; } }
}