My Contributions in Space Shooter

private void FixedUpdate() 
{
    if(!GameManager.Instance.IsGamePlaying)
    {
        return;
    }
    Move(_moveInput);   
}

public void Move(Vector2 moveInput)
{
    _playerRB.AddForce(moveInput * moveSpeed,ForceMode.Impulse);
    Quaternion targetRotation = Quaternion.AngleAxis(moveInput.y * rotateAngle,Vector3.right);
    _playerRB.MoveRotation(Quaternion.Slerp(_playerRB.rotation,targetRotation,rotationSpeed * Time.fixedDeltaTime));    
}

public class Pool
{
    private Queue<PoolObject> _pooledObjects;

    public Pool(PoolObjectData poolObjectData,Transform parentTransform = null)
    {
        _pooledObjects = new Queue<PoolObject>();
        GameObject poolObjectsContainer = new GameObject(poolObjectData.actualObject.name + " Pool");
        if(parentTransform != null)
        {
            poolObjectsContainer.transform.parent = parentTransform;
        }
        for(int i = 0; i < poolObjectData.count; i++)
        {
            PoolObject poolObject = GameObject.Instantiate<PoolObject>(poolObjectData.actualObject);
            poolObject.Pool = this;
            poolObject.transform.parent = poolObjectsContainer.transform;
            poolObject.gameObject.SetActive(false);
            _pooledObjects.Enqueue(poolObject);    
        }
    }
    

    public PoolObject ReuseObject(Vector3 position,Quaternion rotation)
    {
        if(_pooledObjects.Count == 0)
        {
            return null;
        }
        PoolObject poolObject = _pooledObjects.Dequeue();
        poolObject.transform.position = position;
        poolObject.transform.rotation = rotation;
        poolObject.gameObject.SetActive(true);
        poolObject.Reuse();
        return poolObject;
    }

    public void ReturnObjectToPool(PoolObject poolObject)
    {
        if(poolObject == null)
        {
            Debug.LogError("Null object cannot be returned to pool!!");
            return;
        }

        if(!poolObject.Pool.Equals(this))
        {
            Debug.LogError(poolObject.name + " Pool not found!!");
            return;
        }

        _pooledObjects.Enqueue(poolObject);
    }
}

//Weapon powerup data scriptable object
[CreateAssetMenu(menuName = "Scriptable Objects/Weapon Powerup Data", fileName = "Weapon Powerup Data")]
public class WeaponPowerupData : ScriptableObject
{
    [Min(0f)]
    public float PowerUpActiveTime = 4.0f;

    public WeaponType WeaponType;
}

//Powerup class
public abstract class Powerup : MonoBehaviour
{
    [Min(0f)]
    [SerializeField]private float rotatingSpeed = 10f;

    [Min(0f)]
    [SerializeField]private float movingSpeed = 20f;

    [Min(0f)]
    [SerializeField]private float destroyTime = 3f;

    private float _currentTime;

    private void Start() {
        _currentTime = 0f;
    }
    private void Update() 
    {
        if(_currentTime >= destroyTime)
        {
            Destroy(gameObject);
            return;
        }

        _currentTime += Time.deltaTime;
    }
    private void FixedUpdate() 
    {
        transform.Translate(Vector3.right * -movingSpeed * Time.fixedDeltaTime,Space.World);
        transform.Rotate(Vector3.up * rotatingSpeed * Time.fixedDeltaTime,Space.World);
    }

    public abstract void Pickup(GameObject target);
}

//In BaseEnemy class
public virtual void TakeDamage(float amount)
{
    _health.OnHealthDamaged?.Invoke(amount);
    if(_health.CurrentAmount <= 0)
    {
        playerScoreData.IncreaseScore(amount);
        float probability = Random.Range(0f,1f);
        if(probability >= powerupSpawnProbability && powerup != null)
        {
            Instantiate(powerup,transform.position,Quaternion.identity);
        }
        SoundManager.Instance.PlayAtPoint(SoundType.ExplosionSound,transform.position);
        ExplosionManager.Instance?.GenerateExplosionEffect(transform.position,Quaternion.identity);
        base.Destroy();
    }
}