public static void CheckNextAction(ModelNPC.GameDataAlien dataNPC, NameActionsPerson p_actionPerson, GameActionPersonController controller)
    {
        CheckCompletionActions(dataNPC, p_actionPerson, controller);

        var listPersonActions = GetActions(dataNPC);

        //fix WORK
        CheckCurrentAction(dataNPC, ref p_actionPerson);
        //p_actionPerson = GetCurrentAction(dataNPC);

        if (dataNPC.CurrentAction == NameActionsPerson.Completed.ToString())
        {
            if (listPersonActions.Count == 0)
            {
                AddActionNPC(dataNPC, NameActionsPerson.Completed);
            }

            listPersonActions = GetActions(dataNPC);

            if (listPersonActions.Count > 0)
            {
                NameActionsPerson actionPerson = listPersonActions[0];
                listPersonActions.RemoveAt(0);
                dataNPC.PersonActions = listPersonActions.Select(p => p.ToString()).ToArray();// (p=>p.).ToArray();
                StartActionNPC(dataNPC, actionPerson, controller);
            }
        }
        else
        {
            StartActionNPC(dataNPC, p_actionPerson, controller);
        }
    }
 public static void GetCurrentAction_Cache(ref NameActionsPerson result, ModelNPC.GameDataAlien dataNPC)
 {
     if (string.IsNullOrEmpty(dataNPC.CurrentAction))
     {
         dataNPC.CurrentAction = NameActionsPerson.Idle.ToString();
     }
     result = (NameActionsPerson)Enum.Parse(typeof(NameActionsPerson), dataNPC.CurrentAction);;
 }
 private void InitCurrentAction()
 {
     if (temp_ActionPerson == NameActionsPerson.None && temp_ActionPerson == ActionPerson && !string.IsNullOrEmpty(m_dataNPC.CurrentAction))
     {
         temp_ActionPerson = ActionPerson = (NameActionsPerson)Enum.Parse(typeof(NameActionsPerson), m_dataNPC.CurrentAction.ToString());
         StartActionNPC(m_dataNPC, ActionPerson, this);
     }
 }
    public static void CheckCompletionActions(ModelNPC.GameDataAlien dataNPC, NameActionsPerson actionPerson, GameActionPersonController controller)
    {
        //dleLock, Move, Target, TargetLocal, TargetBackToBase
        switch (actionPerson)
        {
        case NameActionsPerson.Idle:
            CheckComplitionIdle(dataNPC, controller);
            break;

        case NameActionsPerson.IdleLock:
            CheckComplitionIdleLock(dataNPC, controller);
            break;

        case NameActionsPerson.Move:
            if (controller != null)
            {
                controller.CheckComplitionMove();
            }
            else
            {
                CheckComplitionMoveInDream(dataNPC);
            }
            break;

        case NameActionsPerson.None:
            if (controller != null)
            {
                controller.ActionPerson = NameActionsPerson.Idle;
            }
            dataNPC.CurrentAction = NameActionsPerson.Idle.ToString();
            break;

        case NameActionsPerson.CompletedLoot:
            CheckComplitionLoot(dataNPC, controller);
            break;

        case NameActionsPerson.Work:
            CheckComplitionWork(dataNPC, controller);
            break;

        case NameActionsPerson.Target:
        case NameActionsPerson.TargetLocal:
        case NameActionsPerson.TargetBackToBase:
            break;

        case NameActionsPerson.Attack:
        case NameActionsPerson.Dead:
        case NameActionsPerson.Completed:

            break;
        }
    }
 public static void CheckCurrentAction(ModelNPC.GameDataAlien dataNPC, ref NameActionsPerson result)
 {
     if (string.IsNullOrEmpty(dataNPC.CurrentAction))
     {
         //Debug.Log("####### GetCurrentAction dataNPC.CurrentAction is null");
         dataNPC.CurrentAction = NameActionsPerson.Idle.ToString();
     }
     if (dataNPC.CurrentAction != NameActionsPerson.Completed.ToString())
     {
         result = (NameActionsPerson)Enum.Parse(typeof(NameActionsPerson), dataNPC.CurrentAction);
     }
     ;
 }
    public static void ExecuteActionNPC(ModelNPC.PersonData dataNPC, NameActionsPerson p_nameAction, GameActionPersonController controller, bool isForce = false)
    {
        if (isForce && controller != null)
        {
            controller.ResetAction();
        }

        if (controller != null)
        {
            controller.ActionPerson = p_nameAction;
        }

        dataNPC.CurrentAction = p_nameAction.ToString();
    }
    public static List <NameActionsPerson> GetActions(ModelNPC.PersonData dataNPC)
    {
        var ListPersonActions = new List <NameActionsPerson>();

        if (dataNPC.PersonActions == null)
        {
            dataNPC.PersonActions = new string[] { }
        }
        ;

        for (int i = 0; i < dataNPC.PersonActions.Length; i++)
        {
            NameActionsPerson nextActon = (NameActionsPerson)Enum.Parse(typeof(NameActionsPerson), dataNPC.PersonActions[i].ToString());;
            ListPersonActions.Add(nextActon);
        }
        return(ListPersonActions);
    }
    public static void RequestActionNPC(ModelNPC.PersonData dataNPC, NameActionsPerson p_nameAction, GameActionPersonController controller, bool isForce = false)
    {
        if (isForce)
        {
            controller.ResetAction();
        }

        if (p_nameAction != NameActionsPerson.Completed)
        {
            AddActionNPC(dataNPC, p_nameAction);
        }

        if (controller != null)
        {
            controller.ActionPerson = NameActionsPerson.Completed;
        }

        dataNPC.CurrentAction = NameActionsPerson.Completed.ToString();
    }
    public static void AddActionNPC(ModelNPC.PersonData dataNPC, NameActionsPerson p_nameAction = NameActionsPerson.None)
    {
        var listPersonActions = GetActions(dataNPC);

        if (listPersonActions.Count() > LimitListCommandActions)
        {
            return;
        }

        if (listPersonActions.Count > 0)
        {
            var lastAction = listPersonActions[listPersonActions.Count - 1];
            if (lastAction == p_nameAction) // repeat
            {
                return;
            }
        }
        listPersonActions.Add(p_nameAction);
        dataNPC.PersonActions = listPersonActions.Select(p => p.ToString()).ToArray();
    }
 public void SetAction(NameActionsPerson p_nameAction)
 {
     ActionPerson = p_nameAction;
 }
    public static void StartActionNPC(ModelNPC.PersonData dataNPC, NameActionsPerson p_nameAction, GameActionPersonController controller)
    {
        if (p_nameAction != NameActionsPerson.None)
        {
            if (controller != null)
            {
                controller.SetAction(p_nameAction);
            }
        }

        if (controller != null)
        {
            dataNPC.CurrentAction = controller.ActionPerson.ToString();
        }
        else
        {
            dataNPC.CurrentAction = p_nameAction.ToString();
        }

        switch (p_nameAction)
        {
        case NameActionsPerson.Idle:
            ActionIdle(dataNPC, controller);
            break;

        case NameActionsPerson.IdleLock:
            ActionIdleLock(dataNPC, controller);
            break;

        case NameActionsPerson.Move:
            if (controller == null)
            {
                ActionMove(dataNPC);
            }
            break;

        case NameActionsPerson.Completed:
            ActionTarget(dataNPC, controller);
            break;

        case NameActionsPerson.Dead:
            break;

        case NameActionsPerson.Attack:
            break;

        case NameActionsPerson.Work:
            ActionWork(dataNPC, controller);
            break;

        case NameActionsPerson.Target:
            ActionTarget(dataNPC, controller);
            break;

        case NameActionsPerson.TargetLocal:
            ActionTargetLocal(dataNPC, controller);
            break;

        case NameActionsPerson.TargetBackToBase:
            ActionTargetBackToBase(dataNPC, controller);
            break;
        }

        //Debug
        if (controller == null || Storage.SceneDebug.SettingsScene.RealDebugOn || Storage.SceneDebug.VipID == dataNPC.Id)
        {
            Storage.SceneDebug.ViewPerson(dataNPC, p_nameAction);
        }
    }
 public void ResetAction()
 {
     temp_ActionPerson = NameActionsPerson.None;
 }