BotAi

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

//Список основных состояний бота.
public enum BotAiState
{
    Guard,//Охрана места(не реализовано)
    FreeHunt,//Бот находит случайную точку в игровом мире и движется туда
    CaptureBase,//Бот стремится на захват вражеской базы
    CaptureFactory,//Бот стремится на захват нейтральных и вражеских заводов
    Repear,//Бот стремится к месту ремонта
}

//Виды текущих (динамических) состояний
public enum BotActionState
{
    Wait,//Ожидание
    FindPath,//Поиск пути
    NoPath,//Не может создать путь в выбранную точку
    Move,//Движение по пути
    EndPath,//Дошёл до конца пути
    Fight,//В бою
    Repear,//Ремонтируется
}

//Это дополнительные динамические состояния для реализации выполнения нескольких действий
public enum BotDubleActionState
{
    None,
    Capture,//Захват базы или завода
}

public class BotAi : MonoBehaviour
{
    private CaptureState captureState;//Ссылка на класс (скрипт, в котором прописана логика захвата базы или завода)
    private BotMove botMove;//(скрипт, в котором прописана логика движения бота)
    public BotState botState;//(скрипт, в котором прописаны ключевые состояния бота и различные параметры (здоровье, скорость и т.п.))
    public BotBodyState botBodyState;//(скрипт, в котором прописана логика поворота головы, башни танка и т.п.)
    public BotAiState botAiState;//
    public BotActionState botActionState;
    public BotDubleActionState botDubleActionState;
    public GameObject wayPointPrefab;//Префаб обьекта случайной точки(в данном префабе описана логика проверки на свободное место)
    public GameObject repearPlaceObj;//Обьект "Место ремонта"
    public GameObject moveTargetObj;//Обьект цель для пути
    public GameObject enemyTargetObj;//Обьект враг. Бот будет вести боевые действия по отношению к этому обьекту
    public GameObject wayPointObj;//Обьекта случайной точки. Если место занято, там где данный обьект создан, обьект сам удаляется, а бот пытается создать такой же в другой случайной позиции

    private NavMeshPath path;//Путь созданный по NavMesh
    private Vector3[] wayPoints;//массив точек на пути
    private int nextPoint;//следующая точка на пути
    private Vector3 currentPoint;//текущая точка на пути
    public int myRandomCheckTime;//локальный контроллер времени при его соответствии с глобальным временем срабатывает поиск вражеских ботов
    public int myTime;//локальный контроллер времени
    private int tmpObjArray;// уже не помню, индекс данного обьекта в массиве, наверное ;)
    public float timeFight;//Счетчик времени, которое бот находится в бою. Каждый раз, когда бот обнаруживает врага, этот счетчик становится  равен timeDangers, и уменьшается в процессе. Когда становится равен 0, бот выходит из состояния боя.
    public float timeDangers = 1000;//Время, которое бот будет в состоянии боя после потери контакта с врагом
    private Color color;//Определял цвет отрисовки пути. Вспомогательняя переменная.
    private BotAiState oldAiState;//Запоминаем старое состояние, что бы вернутся к нему, когад выполение текущего состояния закончено

    void Start()
    {
        //TimerEmult класс счётчик времени, для отсчёта минут и секунд в игре
        myRandomCheckTime = TimerEmult.timersecond;
        myTime = TimerEmult.timersecond;
        botMove = GetComponent<BotMove>();
        botState = GetComponent<BotState>();
    }

    void Update()
    {
        if (botState.botStatus != BotStatus.EndGame)
        {
            AiUpdate();
            CheckTime();
        }
    }

    void AiUpdate()
    {
        if (botState.botStatus == BotStatus.IsOn)
        {
            CreateCharacter();
        }

        if (botState.botStatus == BotStatus.AiControl)
        {
            if (myTime == TimerEmult.timersecond)
            {
                if (botAiState == BotAiState.CaptureBase)
                {
                    LogicCuptureBase();
                }

                if (botAiState == BotAiState.CaptureFactory)
                {
                    LogicCuptureFactory();
                }

                if (botAiState == BotAiState.FreeHunt)
                {
                    LogicFreeHunt();
                }

                if (botAiState == BotAiState.Repear)
                {
                    LogicRepear();
                }
            }

            ActionAi();
        }

        if (botState.botStatus == BotStatus.PlayerControl)
        {
            ProcessRepear();
            ProcessCapture();
        }
    }

    void ActionAi()
    {
        CheckRepear();
        TimeFight();

        if (botActionState == BotActionState.Move)
        {
            LogicMove();
        }

        if (botActionState == BotActionState.Fight)
        {
            LogicFight();
        }

        if (botDubleActionState == BotDubleActionState.Capture)
        {
            if (botState.startCapture == true)
            {
                ProcessCapture();
            }
        }

        if (botActionState == BotActionState.Repear)
        {
            if (botState.startRepear == true)
            {
                ProcessRepear();
            }
            else
            {
                botState.botStatus = BotStatus.IsOn;
            }
        }
    }

    void LogicCuptureBase()
    {
        if (botActionState == BotActionState.Wait)
        {
            if (moveTargetObj != null)
            {
                CreatePath(transform.position, moveTargetObj.transform.position);
            }
            else
            {
                FindBaseArray();
            }
        }

        if (botActionState == BotActionState.EndPath)
        {
            if (botState.placeCapture == true)
            {
                Vector3 randomPlace = new Vector3(Random.Range(3, -3), 0, Random.Range(3, -3));
                CreatePath(transform.position, moveTargetObj.transform.position + randomPlace);
                botActionState = BotActionState.Move;
                botDubleActionState = BotDubleActionState.Capture;
                botState.startCapture = true;

            }
            else
            {
                botActionState = BotActionState.Wait;
            }
        }
    }

    void LogicCuptureFactory()
    {
        if (botActionState == BotActionState.Wait)
        {
            if (moveTargetObj != null)
            {
                CreatePath(transform.position, moveTargetObj.transform.position);
            }
            else
            {
                FindFactoryArray();
            }
        }

        if (botActionState == BotActionState.EndPath)
        {
            if (botState.placeCapture == true)
            {
                Vector3 randomPlace = new Vector3(Random.Range(3, -3), 0, Random.Range(3, -3));
                CreatePath(transform.position, moveTargetObj.transform.position + randomPlace);
                botActionState = BotActionState.Move;
                botDubleActionState = BotDubleActionState.Capture;
                botState.startCapture = true;

            }
            else
            {
                botActionState = BotActionState.Wait;
            }
        }
    }

    void LogicFreeHunt()
    {
        if (botActionState == BotActionState.Wait)
        {
            if (wayPointObj != null)
            {
                moveTargetObj = wayPointObj;
                CreatePath(transform.position, moveTargetObj.transform.position);
            }
            else
            {
                CreateWayPointObj(3, new Vector3(Random.Range(50, -50), transform.position.y, Random.Range(50, -50)));
            }
        }

        if (botActionState == BotActionState.EndPath)
        {
            if (moveTargetObj != null)
            {
                Destroy(moveTargetObj);
                botActionState = BotActionState.Wait;
            }
        }
    }

    void LogicFight()
    {
        if (enemyTargetObj != null)
        {
            /////////////////////////////////////////////
            if (botBodyState != null)
            {
                botBodyState.bodyTarget = enemyTargetObj.transform.position + Vector3.up;//назначаем башне точку, куда необходимо смотреть (вращаться)
            }
            /////////////////////////////////////////////
            //-= Если дистанция до противника большая=-//
            if (Vector3.Distance(transform.position, enemyTargetObj.transform.position) > 30)
            {
                if (myRandomCheckTime == TimerEmult.timersecond)
                {
                    //-=Идем прямо к противнику=-//
                    botMove.aiDirection = new Vector3(0f, 0f, 0.1f);
                }
            }
            else
            {
                if (myRandomCheckTime == TimerEmult.timersecond)
                {
                    //Выбираем случайное направление
                    RandomPosition();
                }
            }
            /////////////////////////////////////////////
            if (Vector3.Angle(transform.position, enemyTargetObj.transform.position) > 5f)
            {
                //-=Поворачиваемся=-//
                botMove.rotateDirection = Quaternion.LookRotation(enemyTargetObj.transform.position - transform.position);
            }
        }
        else
        {
            botActionState = BotActionState.Wait;
        }
    }

    void LogicRepear()
    {
        if (botActionState == BotActionState.Wait)
        {
            if (repearPlaceObj != null)
            {
                moveTargetObj = repearPlaceObj;
                CreatePath(transform.position, moveTargetObj.transform.position);
            }
            else
            {
                botAiState = oldAiState;
            }
        }

        if (botActionState == BotActionState.EndPath)
        {
            botActionState = BotActionState.Repear;
            if (botState.placeRepear == true)
            {
                botState.startRepear = true;
                botState.startReload = true;
            }

        }
    }

    //-=Движемя по пути=-//
    void LogicMove()
    {
        if (Vector3.Distance(transform.position, currentPoint) < 1f)
        {
            //-=Если есть еще точки на пути=-//
            if (nextPoint + 1 < wayPoints.Length)
            {
                //-=Определяем следующую точку=-//
                nextPoint += 1;
                currentPoint = wayPoints[nextPoint];
            }
            else
            {
                //-=Дошли до конечной точки=-//
                botMove.aiDirection = new Vector3(0f, 0f, 0f);
                botActionState = BotActionState.EndPath;
            }
        }
        else
        {
            //-=Движемся по пути=-//
            currentPoint.y = transform.position.y;

            if (myTime == TimerEmult.timersecond)
            {
                botMove.rotateDirection = Quaternion.LookRotation(currentPoint - transform.position);
                botMove.aiDirection = new Vector3(0f, 0f, 0.1f);

                if (botBodyState != null)
                {
                    if (botBodyState.bodyTarget != currentPoint)
                    {
                        botBodyState.bodyTarget = currentPoint;
                    }
                }
            }
        }
    }

    void CreateWayPointObj(float radius, Vector3 position)
    {
        if (wayPointPrefab != null)
        {
            wayPointObj = Instantiate(wayPointPrefab, new Vector3(position.x, position.y + radius, position.z), transform.rotation) as GameObject;
            wayPointObj.transform.localScale = new Vector3(radius, radius, radius);
            wayPointObj.name = "WayPointObj";
        }
        else
        {
            Debug.Log("No prefab wayPointPrefab");
        }
    }

    //-=Создаем путь=-//
    void CreatePath(Vector3 startPosition, Vector3 endPosition)
    {
        path = new NavMeshPath();

        if (NavMesh.CalculatePath(startPosition, endPosition, NavMesh.AllAreas, path))
        {
            GetComponent<ShowGoldenPath>().path = path;
            SetColorPath();
            GetComponent<ShowGoldenPath>().color = color;
            wayPoints = path.corners;
            nextPoint = 0;
            currentPoint = startPosition;
            botActionState = BotActionState.Move;
        }
        else
        {
            Debug.Log("NoPath");
            botActionState = BotActionState.NoPath;
        }
    }

    //-=Ищем обьект базу=-//
    void FindBaseArray()
    {
        float distanceToBase = 1000;//Расстояние до завода
        if (GlobalRoomConfig.arrayBaseState.Count > 0)
        {
            for (int i = 0; i < GlobalRoomConfig.arrayBaseState.Count; i++)
            {
                if (GlobalRoomConfig.arrayBaseState[i].captureState.team != botState.myTeam)
                {
                    if (distanceToBase > Vector3.Distance(GlobalRoomConfig.arrayBaseState[i].transform.position, transform.position))
                    {
                        distanceToBase = Vector3.Distance(GlobalRoomConfig.arrayBaseState[i].transform.position, transform.position);
                        moveTargetObj = GlobalRoomConfig.arrayBaseState[i].gameObject;
                        captureState = GlobalRoomConfig.arrayBaseState[i].GetComponent<CaptureState>();
                    }
                }
            }
        }

        if (moveTargetObj == null)
        {
            for (int i = 0; i < GlobalRoomConfig.arrayBotStateBotRed.Count; i++)
            {
                GlobalRoomConfig.arrayBotStateBotRed[i].botStatus = BotStatus.EndGame;
            }

            for (int i = 0; i < GlobalRoomConfig.arrayBotStateBotBlue.Count; i++)
            {
                GlobalRoomConfig.arrayBotStateBotBlue[i].botStatus = BotStatus.EndGame;
            }
        }
    }

    void FindFactoryArray()
    {
        if (GlobalRoomConfig.arrayFactoryState.Count > 0)
        {
            int rnd = Random.Range(0, GlobalRoomConfig.arrayFactoryState.Count);
            if (rnd == 0)
            {
                float distanceToBase = 1000;
                for (int i = 0; i < GlobalRoomConfig.arrayFactoryState.Count; i++)
                {
                    if (GlobalRoomConfig.arrayFactoryState[i].captureState.team != botState.myTeam)
                    {
                        if (distanceToBase > Vector3.Distance(GlobalRoomConfig.arrayFactoryState[i].transform.position, transform.position))
                        {
                            distanceToBase = Vector3.Distance(GlobalRoomConfig.arrayFactoryState[i].transform.position, transform.position);
                            moveTargetObj = GlobalRoomConfig.arrayFactoryState[i].gameObject;
                            captureState = GlobalRoomConfig.arrayFactoryState[i].GetComponent<CaptureState>();
                        }
                    }
                }
            }
            else
            {
                if (GlobalRoomConfig.arrayFactoryState[rnd] != null)
                {
                    if (GlobalRoomConfig.arrayFactoryState[rnd].captureState.team != botState.myTeam)
                    {
                        moveTargetObj = GlobalRoomConfig.arrayFactoryState[rnd].gameObject;
                        captureState = GlobalRoomConfig.arrayFactoryState[rnd].GetComponent<CaptureState>();
                    }
                }
            }
        }


        if (moveTargetObj == null)
        {
            botAiState = BotAiState.CaptureBase;
        }
    }

    void RandomPosition()
    {
        int rnd = Random.Range(0, 4);

        if (rnd == 0)
        {
            botMove.aiDirection = new Vector3(0f, 0f, -0.1f);
        }

        if (rnd == 1)
        {
            botMove.aiDirection = new Vector3(-0.1f, 0f, 0f);
        }

        if (rnd == 2)
        {
            botMove.aiDirection = new Vector3(0.1f, 0f, 0f);
        }

        if (rnd == 3)
        {
            botMove.aiDirection = new Vector3(0, 0f, -0.1f);
        }
    }

    //контроль времени после потери контакта с противником
    void TimeFight()
    {
        if (timeFight <= 0)
        {
            timeFight = 0;

            if (botActionState == BotActionState.Fight)
            {
                enemyTargetObj = null;
                botActionState = BotActionState.Wait;
            }
        }
        else
        {
            timeFight--;
        }
    }

    void CheckTime()
    {
        if (myRandomCheckTime >= 60)
        {
            myRandomCheckTime = 0;
        }

        if (myRandomCheckTime == TimerEmult.timersecond)
        {
            myRandomCheckTime += Random.Range(2,5);
        }

        if (myTime >= 60)
        {
            myTime = 0;
        }

        if (myTime == TimerEmult.timersecond)
        {
            myTime += 1;
        }
    }

    void CheckRepear()
    {
        if (repearPlaceObj != null)
        {
            if (botActionState != BotActionState.Fight)
            {
                if (botState.health < 100)
                {
                    if (botAiState != BotAiState.Repear)
                    {
                        oldAiState = botAiState;
                        botAiState = BotAiState.Repear;
                        botActionState = BotActionState.Wait;
                    }
                }
            }
        }
    }

    void ProcessRepear()
    {
        if (botState.startRepear == true)
        {
            if (botState.health < 100)
            {
                botMove.animator.SetBool("repear", true);  //проигрываем анимацию ремонт
                botState.health += 1 * Time.deltaTime;
            }
            else
            {
                botMove.animator.SetBool("repear", false);  //проигрываем анимацию ремонт
                botState.startRepear = false;
                botState.health = 100;
                moveTargetObj = null;
            }
        }
    }

    void ProcessCapture()
    {
        if (myTime == TimerEmult.timersecond)
        {
            if (botState.startCapture == true)
            {
                if (captureState.team != botState.myTeam)
                {
                    if (botState.myTeam == "Red")
                    {
                        captureState.captureRed += 10;
                        captureState.captureBlue -= 10;
                    }

                    if (botState.myTeam == "Blue")
                    {
                        captureState.captureBlue += 10;
                        captureState.captureRed -= 10;
                    }
                }
                else
                {
                    moveTargetObj = null;
                    captureState = null;
                    botState.startCapture = false;
                    botActionState = BotActionState.Wait;
                    botDubleActionState = BotDubleActionState.None;
                }
            }
        }
    }

    void CreateCharacter()
    {
        int tmp = Random.Range(0, 2);
        if (tmp == 0) { botAiState = BotAiState.CaptureFactory; }
        if (tmp == 1) { botAiState = BotAiState.CaptureFactory; }

        botActionState = BotActionState.Wait;
        botState.botStatus = BotStatus.AiControl;
        myRandomCheckTime = TimerEmult.timersecond;
        myTime = TimerEmult.timersecond;
    }

    void SetColorPath()
    {
        if (botState.myTeam == "Red")
        {
            color = Color.red;
        }

        if (botState.myTeam == "Blue")
        {
            color = Color.blue;
        }

        if (botAiState == BotAiState.Repear)
        {
            color = Color.green;
        }
    }
}