protected override int OnExecute(BTWorkingData wData)
        {
            AIEntityWorkingData thisData  = wData.As <AIEntityWorkingData>();
            Vector3             targetPos =
                TMathUtils.Vector3ZeroY(
                    thisData.entity.GetBBValue <Vector3>(AIEntity.BBKEY_NEXTMOVINGPOSITION, Vector3.zero));
            Vector3 currentPos   = TMathUtils.Vector3ZeroY(thisData.entityTF.position);
            float   distToTarget = TMathUtils.GetDistance2D(targetPos, currentPos);

            if (distToTarget < 1f)
            {
                thisData.entityTF.position = targetPos;
                return(BTRunningStatus.FINISHED);
            }
            else
            {
                int     ret        = BTRunningStatus.EXECUTING;
                Vector3 toTarget   = TMathUtils.GetDirection2D(targetPos, currentPos);
                float   movingStep = 0.5f * thisData.deltaTime;
                if (movingStep > distToTarget)
                {
                    movingStep = distToTarget;
                    ret        = BTRunningStatus.FINISHED;
                }

                thisData.entityTF.position = thisData.entityTF.position + toTarget * movingStep;
                return(ret);
            }
        }
Beispiel #2
0
        protected override int OnExecute(BTWorkingData wData)
        {
            AIEntityWorkingData thisData = wData.As <AIEntityWorkingData>();
            var targetPos  = thisData.entity.GetBBValue(CBrain.BBKEY_NEXTMOVINGPOSITION, LVector2.zero);
            var currentPos = thisData.entityTF.pos;

            if ((targetPos - currentPos).sqrMagnitude < 1)
            {
                return(BTRunningStatus.FINISHED);
            }
            else
            {
                var  turnVal          = 150 * thisData.deltaTime;
                bool isReachTargetDeg = false;
                var  fdeg             = CTransform2D.TurnToward(targetPos, currentPos, thisData.entityTF.deg, turnVal,
                                                                out isReachTargetDeg);
                thisData.entityTF.deg = fdeg;
                if (isReachTargetDeg)
                {
                    return(BTRunningStatus.FINISHED);
                }
            }

            return(BTRunningStatus.EXECUTING);
        }
Beispiel #3
0
        protected override int OnExecute(BTWorkingData wData)
        {
            var thisData     = wData.As <AIEntityWorkingData>();
            var targetPos    = thisData.entity.GetBBValue(CBrain.BBKEY_NEXTMOVINGPOSITION, LVector2.zero);
            var currentPos   = thisData.entityTF.pos;
            var distToTarget = (targetPos - currentPos).magnitude;

            if (distToTarget < 1)
            {
                thisData.entityTF.pos = targetPos;
                return(BTRunningStatus.FINISHED);
            }
            else
            {
                int ret        = BTRunningStatus.EXECUTING;
                var toTarget   = (targetPos - currentPos).normalized;
                var movingStep = 2 * thisData.deltaTime;
                if (movingStep > distToTarget)
                {
                    movingStep = distToTarget;
                    ret        = BTRunningStatus.FINISHED;
                }

                thisData.entityTF.pos = thisData.entityTF.pos + toTarget * movingStep;
                return(ret);
            }
        }
Beispiel #4
0
 public override object[] GetRuntimeData(BTWorkingData wData)
 {
     return(new object[] {
         *(BTCActionLeaf *)wData.GetContext(_uniqueKey),
         *(UserContextData *)GetUserContextData(wData)
     });
 }
        protected override void OnEnter(BTWorkingData wData)
        {
            AIEntityWorkingData thisData = wData.As <AIEntityWorkingData>();
            var userData = (UserContextData *)GetUserContextData(wData);

            userData->attackingTime = DEFAULT_WAITING_TIME;
            thisData.entity.PlayAnimation("Attack");
        }
Beispiel #6
0
        public override bool IsTrue(BTWorkingData wData)
        {
            var thisData   = wData.As <AIEntityWorkingData>();
            var targetPos  = thisData.entity.GetBBValue(CBrain.BBKEY_NEXTMOVINGPOSITION, LVector2.zero);
            var currentPos = thisData.entityTF.pos;

            return((targetPos - currentPos).sqrMagnitude < 1);
        }
Beispiel #7
0
        protected override void OnEnter(BTWorkingData wData)
        {
            var thisData = wData.As <AIEntityWorkingData>();
            var userData = (UserContextData *)GetUserContextData(wData);

            userData->attackingTime = waitTime;
            thisData.entity.PlayAnimation("Attack");
        }
        public override bool IsTrue(BTWorkingData wData)
        {
            AIEntityWorkingData thisData  = wData.As <AIEntityWorkingData>();
            Vector3             targetPos =
                TMathUtils.Vector3ZeroY(
                    thisData.entity.GetBBValue <Vector3>(AIEntity.BBKEY_NEXTMOVINGPOSITION, Vector3.zero));
            Vector3 currentPos = TMathUtils.Vector3ZeroY(thisData.entityTF.position);

            return(TMathUtils.GetDistance2D(targetPos, currentPos) < 1f);
        }
        protected override void OnEnter(BTWorkingData wData)
        {
            AIEntityWorkingData thisData = wData.As <AIEntityWorkingData>();

            if (thisData.entity.IsDead)
            {
                thisData.entity.PlayAnimation("Reborn");
            }
            else
            {
                thisData.entity.PlayAnimation("Walk");
            }
        }
        protected override int OnExecute(BTWorkingData wData)
        {
            AIEntityWorkingData thisData = wData.As <AIEntityWorkingData>();
            var userData = (UserContextData *)GetUserContextData(wData);

            if (userData->attackingTime > 0)
            {
                userData->attackingTime -= thisData.deltaTime;
                if (userData->attackingTime <= 0)
                {
                    thisData.entityAnimator.SetInteger("DeadRnd", Random.Range(0, 3));
                    thisData.entity.PlayAnimation("Dead");
                    thisData.entity.IsDead = true;
                }
            }

            return(BTRunningStatus.EXECUTING);
        }
        protected override int OnExecute(BTWorkingData wData)
        {
            AIEntityWorkingData thisData  = wData.As <AIEntityWorkingData>();
            Vector3             targetPos =
                TMathUtils.Vector3ZeroY(
                    thisData.entity.GetBBValue <Vector3>(AIEntity.BBKEY_NEXTMOVINGPOSITION, Vector3.zero));
            Vector3 currentPos = TMathUtils.Vector3ZeroY(thisData.entityTF.position);

            if (TMathUtils.IsZero((targetPos - currentPos).sqrMagnitude))
            {
                return(BTRunningStatus.FINISHED);
            }
            else
            {
                Vector3 toTarget   = TMathUtils.GetDirection2D(targetPos, currentPos);
                Vector3 curFacing  = thisData.entityTF.forward;
                float   dotV       = Vector3.Dot(toTarget, curFacing);
                float   deltaAngle = Mathf.Acos(Mathf.Clamp(dotV, -1f, 1f));
                if (deltaAngle < 0.1f)
                {
                    thisData.entityTF.forward = toTarget;
                    return(BTRunningStatus.FINISHED);
                }
                else
                {
                    Vector3 crossV      = Vector3.Cross(curFacing, toTarget);
                    float   angleToTurn = Mathf.Min(3f * thisData.deltaTime, deltaAngle);
                    if (crossV.y < 0)
                    {
                        angleToTurn = -angleToTurn;
                    }

                    thisData.entityTF.Rotate(Vector3.up, angleToTurn * Mathf.Rad2Deg, Space.World);
                }
            }

            return(BTRunningStatus.EXECUTING);
        }
 public override bool IsTrue(/*in*/ BTWorkingData wData)
 {
     return(GetChild <BTPrecondition>(0).IsTrue(wData) ||
            GetChild <BTPrecondition>(1).IsTrue(wData));
 }
 public override bool IsTrue(/*in*/ BTWorkingData wData)
 {
     return(false);
 }