AI运动层的一套基于加速度的基本移动方案

最新推荐文章于 2023-12-25 21:53:30 发布
最新推荐文章于 2023-12-25 21:53:30 发布
阅读量1.3k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovethRain/article/details/69388892
版权


移动组件：

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

public class MoveComponent : MonoBehaviour
{


    #region 字段
    public float maxSpeed = 10;                                                               // 最大速度
    public float maxForce = 100;                                                              // 最大推力
    public float mass = 1;                                                                    // 对象质量
    public Vector3 velocity;                                                                  // 速度向量
    public float damping = 0.9f;                                                              // 旋转速率
    public float computeInteval = 0.2f;                                                       // 计算间隔
    public float completeDisatnce = 3f;                                                       // 到达距离
    private Vector3 acceleration;                                                             // 加速度
    private float timer = 0;                                                                  // 计时器
    private Vector3 steeringForce = Vector3.zero;                                             // 推力
    private Dictionary<MoveType, MoveBase> moveDic = new Dictionary<MoveType, MoveBase>();    // 移动字典
    public List<MoveType> arriveRemove = new List<MoveType>();                                // 移动完成需要删除的移动
    #endregion

    void Awake()
    {
        moveDic[MoveType.Seek] = null;
        moveDic[MoveType.Arrive] = null;
        moveDic[MoveType.Flee] = null;
        moveDic[MoveType.FollowPath] = null;
        moveDic[MoveType.Pursuit] = null;
        moveDic[MoveType.CollisionAvoidance] = null;
    }

    void Update()
    {
        timer += Time.deltaTime;

        if(timer > computeInteval)
        {
            //得到当前帧的推力
            steeringForce = Vector3.zero;
            //遍历当前激活的移动并添加推力*权重
            foreach(var v in moveDic)
            {
                if(v.Value != null)
                {
                    steeringForce += v.Value.Force() * v.Value.Weight;
                }
            }

            //移除完成的移动
            foreach (var v in arriveRemove)
            {
                moveDic[v] = null;
            }
            arriveRemove.Clear();

            //限制最大力
            steeringForce = Vector3.ClampMagnitude(steeringForce, maxForce);
            //加速度=推力/质量
            acceleration = steeringForce / mass;

            timer = 0;
        }
    }

    void FixedUpdate()
    {
        //增加加速度
        velocity += acceleration * Time.fixedDeltaTime;

        //控制最大速度
        if (velocity.sqrMagnitude > maxSpeed * maxSpeed)
            velocity = velocity.normalized * maxSpeed;

        //移动
        transform.position += velocity * Time.fixedDeltaTime;

        //插值旋转
        if(velocity.sqrMagnitude > 0.01f)
        {
            //计算当前前方到目标方向的插值
            Vector3 newForward = Vector3.Slerp(transform.forward, velocity, damping * Time.fixedDeltaTime);
            transform.forward = newForward;
        }

    }


    #region 接口

    public void SeekTo(Transform target)
    {
        if(moveDic[MoveType.Seek] != null)
        {
            if ((moveDic[MoveType.Seek] as MoveSeek).target == target)
                return;
        }
        moveDic[MoveType.Seek] = new MoveSeek(this, target);
    }

    public void ArriveTo(Transform target, float slowDistance)
    {
        if (moveDic[MoveType.Arrive] != null)
        {
            if ((moveDic[MoveType.Arrive] as MoveArrive).target == target)
                return;
        }
        moveDic[MoveType.Arrive] = new MoveArrive(this, target, slowDistance);
    }

    public void FleeTo(Transform target,float fearDistance)
    {
        if (moveDic[MoveType.Flee] != null)
        {
            if ((moveDic[MoveType.Flee] as MoveFlee).target == target)
                return;
        }
        moveDic[MoveType.Flee] = new MoveFlee(this, target, fearDistance);
    }

    public void PursuitTo(Transform target)
    {
        if(moveDic[MoveType.Pursuit] != null)
        {
            if ((moveDic[MoveType.Pursuit] as MovePursuit).target == target)
                return;
        }
        moveDic[MoveType.Pursuit] = new MovePursuit(this, target);
    }

    public void FollowPath(List<Transform> path)
    {
        if(moveDic[MoveType.FollowPath] != null)
        {
            if ((moveDic[MoveType.FollowPath] as MoveFllowPath).path == path)
                return;
        }
        moveDic[MoveType.FollowPath] = new MoveFllowPath(this, path);
    }

    public void OpenCollisionAvoidance(float seeAheadDistance)
    {
        moveDic[MoveType.CollisionAvoidance] = new MoveCollisionAvoidance(this, seeAheadDistance);
    }

    #endregion

}

public enum MoveType
{
    Seek,
    Arrive,
    Flee,
    Pursuit,
    FollowPath,
    CollisionAvoidance
}



移动方式基类：

using UnityEngine;
using System.Collections;

public class MoveBase  {

    public float Weight = 1;                 //移动优先级
    protected Vector3 disiredVelocity;       //目标速度
    protected MoveComponent move;            //移动脚本

    public MoveBase(MoveComponent move)
    {
        this.move = move;
    }

    public virtual Vector3 Force()
    {
        return Vector3.zero;
    }


}


靠近：

using UnityEngine;
using System.Collections;

public class MoveSeek : MoveBase {

    public Transform target;

    public MoveSeek(MoveComponent move, Transform target) : base(move) { this.target = target; } 

    public override Vector3 Force()
    {
        //完成目标移除
        if (Vector3.Distance(target.transform.position, move.transform.position) < move.completeDisatnce)
        {
            move.arriveRemove.Add(MoveType.Seek);
            move.velocity = Vector3.zero;
            return Vector3.zero;
        }
        //要到达的速度
        disiredVelocity = (target.transform.position - move.transform.position).normalized * move.maxSpeed;
        //加速度：当速度=要到达的速度，加速度为0
        return disiredVelocity - move.velocity;
    }

}


缓速到达：

using UnityEngine;
using System.Collections;

public class MoveArrive : MoveBase {

    public Transform target;
    //减速范围
    float slowDistance;

    public MoveArrive(MoveComponent move, Transform target, float slowDistance) : base(move) { this.target = target; this.slowDistance = slowDistance; }

    public override Vector3 Force()
    {
        if (Vector3.Distance(target.transform.position, move.transform.position) > move.completeDisatnce)
        {
            Vector3 toTarget = target.transform.position - move.transform.position;
            Vector3 returnForce;

            float distance = toTarget.magnitude;

            if (distance > slowDistance)
            {
                //目标速度
                disiredVelocity = toTarget * move.maxSpeed;
                //加速度：当速度=要到达的速度，加速度为0
                returnForce = disiredVelocity - move.velocity;
            }
            else
            {
                //当进入减速范围时 目标速度 = 长度向量-速度向量 逐渐缩小
                disiredVelocity = toTarget - move.velocity;
                returnForce = disiredVelocity - move.velocity;
            }
            return returnForce;
        }
        else
        {
            //完成目标移除
            move.arriveRemove.Add(MoveType.Arrive);
            move.velocity = Vector3.zero;
            return Vector3.zero;
        }

    }

}


逃离：

using UnityEngine;
using System.Collections;

public class MoveFlee : MoveBase {

    public Transform target;
    float fearDistance;

    public MoveFlee(MoveComponent move, Transform target, float fearDistance) : base(move) { this.target = target; this.fearDistance = fearDistance; }

    public override Vector3 Force()
    {
        if(Vector3.Distance(move.transform.position,target.position) > fearDistance)
        {
            //完成目标移除
            move.arriveRemove.Add(MoveType.Flee);
            move.velocity = Vector3.zero;
            return Vector3.zero;
        }
        //反方向加速度向量
        disiredVelocity = (move.transform.position - target.position).normalized * move.maxSpeed;
        return disiredVelocity - move.velocity;
    }

}


路径移动：

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

public class MoveFllowPath : MoveBase {

    public List<Transform> path = new List<Transform>();
    private float slowDistance = 5f;
    private Transform target;
    private int index = 0;

    public MoveFllowPath(MoveComponent move, List<Transform> path) : base(move) { this.path = path; target = path[index]; }

    public override Vector3 Force()
    {
        Vector3 returnForce = Vector3.zero;
        Vector3 distance = target.position - move.transform.position;
        //最后一点
        if (index == path.Count - 1)
        {
            if (Vector3.Distance(target.position, move.transform.position) < move.completeDisatnce)
            {
                //完成目标移除
                move.arriveRemove.Add(MoveType.FollowPath);
                move.velocity = Vector3.zero;
                return Vector3.zero;
            }

            if (distance.magnitude > slowDistance)
            {
                disiredVelocity = distance.normalized * move.maxSpeed;
            }
            else
            {
                disiredVelocity = distance - move.velocity;
            }
            returnForce = disiredVelocity - move.velocity;
        }
        else
        {
            if(Vector3.Distance(target.position,move.transform.position) < move.completeDisatnce)
            {
                index++;
                target = path[index].transform;
            }
            disiredVelocity = distance.normalized * move.maxSpeed;
            returnForce = disiredVelocity - move.velocity;
        }
        return returnForce;
    }

}


拦截：

using UnityEngine;
using System.Collections;

public class MovePursuit : MoveBase {


    public Transform target;

    public MovePursuit(MoveComponent move, Transform target) : base(move) { this.target = target; }

    public override Vector3 Force()
    {
        if(target.GetComponent<MoveComponent>()==null)
        {
            move.arriveRemove.Add(MoveType.Pursuit);
            return Vector3.zero;
        }

        if (Vector3.Distance(target.transform.position, move.transform.position) > move.completeDisatnce)
        {
            Vector3 toTarget = target.transform.position - move.transform.position;
            //两个对象的前方向量夹角
            float relativeDirection = Vector3.Dot(move.transform.forward, target.transform.forward);
            //追踪向量和对象前方向量的夹角>0并且两个对象前方夹角<18
            if(Vector3.Dot(toTarget,move.transform.forward) > 0 && relativeDirection < -0.95f)
            {
                //差不多在一直线上
                disiredVelocity = (target.transform.position - move.transform.position).normalized * move.maxSpeed;
                return disiredVelocity - move.velocity;
            }

            //预期到达目标的前方位置的时间
            float lookheadTime = toTarget.magnitude / (move.maxSpeed + target.GetComponent<MoveComponent>().velocity.magnitude);

            //预期目标位置 = 目标位置 + 目标速度*预期到达时间
            disiredVelocity = (target.transform.position + target.GetComponent<MoveComponent>().velocity * lookheadTime - move.transform.position).normalized * move.maxSpeed;

            return disiredVelocity - move.velocity;
        }
        else
        {
            //完成目标移除
            move.arriveRemove.Add(MoveType.Pursuit);
            move.velocity = Vector3.zero;
            return Vector3.zero;
        }

    }

}


避障：

using UnityEngine;
using System.Collections;

public class MoveCollisionAvoidance : MoveBase {

    private float maxSeeAhead = 2.0f;

    public MoveCollisionAvoidance(MoveComponent move, float maxSeeAhead) : base(move) { this.maxSeeAhead = maxSeeAhead;  }


    public override Vector3 Force()
    {

        RaycastHit hit;
        Vector3 returnForce = Vector3.zero;

        //方向：速度向量 距离：视线 * 时间
        if(Physics.Raycast(move.transform.position,move.velocity,out hit,maxSeeAhead * move.velocity.magnitude /move.maxSpeed))
        {
            //发生碰撞的视线前方向量
            Vector3 ahead = move.transform.position + move.velocity * maxSeeAhead * (move.velocity.magnitude /move.maxSpeed);
            //用视线向量-碰撞物体的中心点 得到 碰撞物体中心指向视线向量的向量 用这个向量来偏移
            returnForce = ahead - hit.collider.transform.position;
            returnForce *= move.maxForce;
            returnForce.y = 0;

        }

        return returnForce;

    }




}




lovethRain
关注
C#维特智能蓝牙5.0加速度陀螺仪角度姿态传感器协议解析源码
05-10
C# WinForm 维特智能蓝牙5.0加速度陀螺仪角度姿态传感器协议解析源码
Unity Vector3.Dot(VectorA, VectorB)
Wilhelm的博客
11-21 5892
Unity Vector3.Dot(VectorA, VectorB) Vector3.Dot(VectorA, VectorB) 等于 VectorA * VectorB。 而对于两个向量的乘积计算如下：
Vector3.Dot用法
Simon
06-25 1万+
Vector3.Dot也叫点积，它返回1个-1.0～1.0之间的一个值。网上确实也这么说。但是这个值表示什么呢？恩，表示返回进行Dot计算的两个向量之间的夹角的余弦值(Cos弧度角).要注意的是能进行Dot计算的前提是两个向量首先要变成单位向量！ public class DotTest : MonoBehaviour {   public Vector3 v1; public V
threejs向量Vector3点乘.dot()
最新发布
u014291990的博客
12-25 970
dot()
Unity3D之Vector3.Dot和Vector3.Cross的使用
qq_39816832的博客
03-13 4677
在Unity3D中，Vector3.Dot表示求两个向量的点积;Vector3.Cross表示求两个向量的叉积。   点积计算的结果为数值，而叉积计算的结果为向量。两者要注意区别开来。   在几何数学中：   1.点积   点积的计算方式为: a·b=|a|·|b|cos 其中|a|和|b|表示向量的模，表示两个向量的夹角。另外在点积中，和 夹角是不分顺序的。   所以通过点
MGRA：通过加速度计进行运动手势识别
03-23
其中，运动手势识别（Motion Gesture Recognition, MGR）是近年来的一个热门研究领域，它利用内置的加速度计数据来理解用户的手势动作，为用户提供无缝的交互体验。 本文提出了一种名为MGRA（Motion Gesture ...
移动小额信贷平台方案.pptx
09-30
为了解决上述问题，本方案提出了一套面向中小企业小额信贷的移动销售客户管理系统，该系统包括以下几个关键组件： 1. 信息收集：采用电子表单，现场完成信息填写，减少纸质资料的使用。 2. 现场拍照：利用手机拍摄...
基于人工智能的95598智慧客服的构建.pdf
07-11
本文档《基于人工智能的95598智慧客服的构建》详细探讨了人工智能在智慧客服领域的应用，以及如何利用大数据和AI技术创新服务模式和运营模式，为客户提供更加精细化的服务。 首先，文档介绍了智能语音导航的重要性...
智能综合体策划方案培训资料
06-16
构建一套完整的智能综合体策划方案，旨在通过智能化手段提升商业综合体的安全防护能力、运营管理水平和用户体验，最终实现经济效益和社会效益的双赢。 #### 第二章 系统总体思路 **2.1 指导思想（设计思想）** 本...
传感器组合可以实现更加智能的移动设备
07-22
- **加速度计**：监测设备的物理运动，用于屏幕方向自动旋转等功能。 - **麦克风**：除了基本的通话功能外，还可以用来检测环境噪声水平。 这些传感器各自独立工作，但在实际应用中，它们之间的协同作用可以实现更...
Vector3.Dot(点积)与Vector3.Cross(叉积)判断敌人相对于角色的方位——Unity的API学习篇
weixin_45373419的博客
08-11 3342
概念理解：          向量的点积：               向量的点积又称为数量积或内积，计算方式：两向量的模与其夹角的余弦值相乘，例如a和b两个向量，a·b...
Vector3.Dot
qq_29172391的博客
07-25 335
a.transform.position这两个向量，当cube（2）在自身（cube）的前方时，其夹角永远小于90°，在后方时，永远大于90°，如此可依据点乘来判断“敌人”相对于自身的位置（前方or后方）这里我将两个向量传入，第一个为cube本身的正方向，第二个为cube指向cube（2）的方向，由于向量点乘等于其各自模长相乘再乘上二者之间的余弦值，所以Vector3.Dot返回值的正负取决于其夹角。如图：cube在cube（2）的前方、
Vector3.Dot 与Vector3.Cross
klwuxie的专栏
10-10 1161
转载：http://blog.csdn.net/cxihu/article/details/46833443 Vector3.Dot（点积） ： 点积的计算方式为:  a·b=|a|·|b|cos; 其中和 夹角不分顺序; 物理学中点积用来计算力沿物体运动的方向所做的功：W=F*S=|F|*|S|*cosθ;功是数量，故点积又称数量积，无向积等; 通过点积的
关于Unity3d中Vector3.Dot方法
xinshou_jiaoming的专栏
09-23 1万+
在网络上关于Vector3.Dot的解释都不清除，其实Vector3.Dot方法很简单。 Vector3.Dot也叫点积，它返回1个-1.0～1.0之间的一个值。网上确实也这么说。但是这个值表示什么呢？恩，表示返回进行Dot计算的两个向量之间的夹角的余弦值(Cos弧度角).要注意的是能进行Dot计算的前提是两个向量首先要变成单位向量！ public class DotT
Unity3D_向量（Vector3）数学基础
热门推荐
bobo553443的博客
03-08 7万+
向量（Vector3） 在虚拟的游戏世界中，3D数学决定了游戏，如何计算和模拟出开发者以及玩家看到的每一帧画面。学习基础的3D数学知识可以帮主用户对游戏引擎产生更深刻的了解。向量定义：既有大小又有方向的量叫做向量。在空间中，向量用一段有方向的线段来表示。应用十分广泛，可用于描述具有大小和方向两个属性的物理量，例如物体运动的速度、加速度、摄像机观察方向、刚体受到的力等都是向量。因此向量是物理、动...
Unity向量的点乘和叉乘的使用
加加油！
04-20 3793
Unity中点乘和叉乘点乘（API: Vector3.Dot()）点乘的计算公式点乘的几何意义用途之一：判断一个物体当前方位利用点乘求出角度叉乘（API: Vector3.Cross()）叉乘计算公式叉乘的几何意义判断物体是在左侧还是右侧 点乘（API: Vector3.Dot()） 点乘的计算公式 向量A(X1,Y1,Z1) 向量B(X2,Y2,Z2) A•B=X1*X2+Y1*Y2+Z1*Z2 向量•向量=标量（一个数值没有方向） 点乘的几何意义 点乘可以得到一个向量在自己向量上`投影的长度 如下图所示
浅谈Vector3的点积与叉积
ykr168age的专栏
07-29 1415
一、点积（又称“数量积”、“内积”）     1、理论知识    在数学中，点积的定义为a·b=|a|·|b|cos 【注：粗体小写字母表示向量，表示向量a,b的夹角，取值范围为[0，π]】。从定义上，我们知道向量的点积得到的是一个数值。而不是向量（这点大家要注意了！要与叉积进行区别）。另外点积中的夹角没有顺序可言，即=（或a·b=b·a）。所以我们可以通过点积得到两个向量之间的夹角。
unity中三维数学
jjjndk1314的博客
12-10 5551
向量相减,向量相加 如上图a-b为c, a+b为d —&amp;gt; 在unity中相加相减后向量起点为加减向量公共起点 向量与数的乘与除 —&amp;gt; 模长的缩放 向量与向量的乘与除 —&amp;gt;1.点乘Dot:[x1,y1,z1][x1,y2,z2] = x1x2+y1y2+z1x2 参与点乘运算的向量标准化后,结果为夹角的 cos 值,几何意义Dot(a,b) = |a||b|*cos(a,b)...
基于加速度计与陀螺仪的头部动作控制系统设计
还有基于双目视觉的智能轮椅，通过人眼移动来控制。此外，语音识别也是一种常见方法，通过识别语音信息来操纵设备。 本文聚焦的头部动作识别系统则采用加速度计和陀螺仪组合，它们能够检测并解析人的头部机械运动。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值