Approach1

using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using UnityEngine;
using UnityEngine.Jobs;
using System.Collections.Generic;

public class ManagerEnemies : MonoBehaviour {

    [Header("Enemy Manager Settings")]
    [SerializeField] private Transform player;
    [SerializeField] private int maxNumEnemies = 5000;
    [SerializeField] private string sounds = "Game/Enemies/";
    [Space(20)]
    [Header("Debugging")]
    [SerializeField] private bool DebugMode = false;
    [SerializeField] private bool enableAvoidance = true;
    [SerializeField] private bool enableReAllocation = true;
    [SerializeField] public int numEnemies;
    [SerializeField] public int globalAvoidanceRadius;

    private EnemyUnit[] enemyUnits;
    private List<EnemyUnit> reAllocUnits;

    private TransformAccessArray enemyTransforms;
    private JobHandle enemyMoveJobHandle;

    private void Awake() {
        enemyUnits = new EnemyUnit[maxNumEnemies];
        reAllocUnits = new List<EnemyUnit>();
        enemyTransforms = new TransformAccessArray(maxNumEnemies);
    }

    private void Update() {
        enemyMoveJobHandle.Complete();
        enemyMoveJobHandle = MoveEnemiesJob();
        enemyMoveJobHandle.Complete();
    }

    private JobHandle MoveEnemiesJob() {
        var job = new MoveEnemiesJob {
            playerPosition = player.position,
            enemyUnits = new NativeArray<EnemyUnit>(enemyUnits, Allocator.TempJob),
            enemyTransforms = enemyTransforms,
            enableAvoidance = enableAvoidance,
            numEnemies = numEnemies,
            deltaTime = Time.deltaTime
        };
        var jobHandle = job.Schedule(enemyUnits.Length, 64);
        return jobHandle;
    }

    private void LateUpdate() {
        enemyMoveJobHandle.Complete();
    }

    private void OnDestroy() {
        enemyMoveJobHandle.Complete();
        enemyTransforms.Dispose();
    }

    public void RegisterEnemyUnit(EnemyUnit enemy) {
        if (numEnemies < maxNumEnemies) {
            enemyUnits[numEnemies] = enemy;
            enemyTransforms.Add(enemy.transform);
            numEnemies++;
        } else {
            if (DebugMode) { Debug.LogError("Maximum number of enemy units reached!"); }
        }
    }

    public void UnregisterEnemyUnit(EnemyUnit enemy) {
        int index = System.Array.IndexOf(enemyUnits, enemy);
        if (index >= 0) {
            for (int i = index; i < numEnemies - 1; i++) {
                enemyUnits[i] = enemyUnits[i + 1];
            }
            numEnemies--;
            enemyUnits[numEnemies] = null;
            enemyTransforms.RemoveAtSwapBack(index);
        } else {
            if (DebugMode) { Debug.LogError("[<color=red>-</color>] Enemy unit not found in manager: " + enemy.uid.ToString()); }
        }
    }

    [BurstCompile]
    private struct MoveEnemiesJob : IJobParallelForTransform {
        public Vector3 playerPosition;
        public NativeArray<EnemyUnit> enemyUnits;
        public TransformAccessArray enemyTransforms;
        public bool enableAvoidance;
        public int numEnemies;
        public float deltaTime;

        public void Execute(int index, TransformAccess transform) {
            EnemyUnit enemyUnit = enemyUnits[index];
            Vector3 direction = playerPosition - transform.position;
            if (direction.magnitude > enemyUnit.playerRadius + enemyUnit.unitRadius) {
                Vector3 movementDirection = direction.normalized;
                float detectionAngle = 30f;
                float moveSpeed = enemyUnit.speed;
                Collider[] hitColliders = Physics.OverlapSphere(transform.position, 2f, LayerMask.GetMask("Enemy"));
                foreach (Collider collider in hitColliders) {
                    if (collider != enemyUnit.GetComponent<Collider>())
                    {
                        Vector3 targetDirection = collider.transform.position - transform.position;
                        float angle = Vector3.Angle(movementDirection, targetDirection);
                        if (angle < detectionAngle)
                        {
                            moveSpeed = enemyUnit.speed / 2f;
                            break;
                        }
                    }
                }
                transform.rotation = Quaternion.Euler(0f, transform.rotation.eulerAngles.y, transform.rotation.eulerAngles.z);
                transform.position = new Vector3(transform.position.x, 0f, transform.position.z);
                //transform.LookAt(playerPosition);
                transform.position += movementDirection * moveSpeed * deltaTime;
            } else {
                Debug.Log("Attacking...");
            }
        }
    }
}