AI 学习

极简状态机:

/*
脚本名称:
脚本作者:
建立时间:
脚本功能:
版本号:
*/
using UnityEngine;
using System.Collections;

namespace VoidGame {

    public class Player : MonoBehaviour {

        /// <summary>
        /// 移动速度
        /// </summary>
        public float m_moveSpeed = 10.0f;

        private void Update() {
            Move();
        }

        private void Move() {
            Vector3 direction = Vector3.zero;
            if(Input.GetKey(KeyCode.W)) {
                direction = transform.forward;
            }
            if(Input.GetKey(KeyCode.S)) {
                direction = -transform.forward;
            }
            if(Input.GetKey(KeyCode.A)) {
                direction = -transform.right;
            }
            if(Input.GetKey(KeyCode.D)) {
                direction = transform.right;
            }
            transform.Translate(direction * Time.deltaTime * m_moveSpeed,Space.World);
        }
    }
}

/*
脚本名称:
脚本作者:
建立时间:
脚本功能:
版本号:
*/
using UnityEngine;
using UnityEngine.UI;
using System.Collections;

namespace VoidGame {

    /// <summary>
    /// 状态
    /// </summary>
    public enum FSMState {
        /// <summary>
        /// 巡逻
        /// </summary>
        Patrol,
        /// <summary>
        /// 追逐
        /// </summary>
        Chase,
        /// <summary>
        /// 攻击
        /// </summary>
        Attack,
        /// <summary>
        /// 死亡
        /// </summary>
        Dead
    }

    public class Enemy : MonoBehaviour {

        /// <summary>
        /// 玩家
        /// </summary>
        public Transform m_player;

        /// <summary>
        /// 路标列表
        /// </summary>
        public Transform[] m_waypoints;
        /// <summary>
        /// 目标路标索引
        /// </summary>
        private int m_targetWaypointIndex;

        /// <summary>
        /// 移动速度
        /// </summary>
        public float m_moveSpeed = 0.1f;

        /// <summary>
        /// 状态
        /// </summary>
        public FSMState m_fsmState;

        /// <summary>
        /// 和玩家的距离
        /// </summary>
        public float m_distance;

        /// <summary>
        /// 追逐距离
        /// </summary>
        private float m_chaseDistance = 5f;
        /// <summary>
        /// 攻击距离
        /// </summary>
        private float m_attackDistance = 2f;

        [Space(10)]
        public Text m_text;

        private void Start() {
            //初始状态:巡逻
            m_fsmState = FSMState.Patrol;
            //设置初始目标路标索引
            m_targetWaypointIndex = 0;
        }

        private void Update() {
            //根据状态切换
            switch(m_fsmState) {
            case FSMState.Patrol:
                UpdatePatrolState();
                break;
            case FSMState.Chase:
                UpdateChaseState();
                break;
            case FSMState.Attack:
                UpdateAttackState();
                break;
            case FSMState.Dead:
                break;
            }

            DisplayDistance();
        }

        private void OnDrawGizmos() {
            //画自身的前方向
            iTween.DrawLine(new Vector3[] { transform.position,transform.position + transform.forward },Color.yellow);

            //根据状态画和玩家之间的关联线
            switch(m_fsmState) {
            case FSMState.Patrol:
                
                break;
            case FSMState.Chase:
                DrawLine(Color.green);
                break;
            case FSMState.Attack:
                DrawLine(Color.red);
                break;
            case FSMState.Dead:
                break;
            }
            

        }

        /// <summary>
        /// 更新巡逻状态
        /// </summary>
        private void UpdatePatrolState() {
            if(!IsArrived()) {
                Move(m_waypoints[m_targetWaypointIndex]);
            }
            if(CalculateDistance() <= m_chaseDistance) {
                m_fsmState = FSMState.Chase;
            }
        }

        /// <summary>
        /// 更新追逐状态
        /// </summary>
        private void UpdateChaseState() {
            Move(m_player);
            //小于等于攻击距离,攻击
            if(CalculateDistance() <= m_attackDistance) {
                m_fsmState = FSMState.Attack;
            //大于攻击距离并且小于等于追逐距离,追逐
            } else if(CalculateDistance() > m_attackDistance && CalculateDistance() <= m_chaseDistance) {
                m_fsmState = FSMState.Chase;
            //其余情况也就是大于追逐距离,巡逻
            } else {
                m_fsmState = FSMState.Patrol;
            }
        }

        /// <summary>
        /// 更新攻击状态
        /// </summary>
        private void UpdateAttackState() {
            //大于攻击距离并且小于等于追逐距离,追逐
            if(CalculateDistance() > m_attackDistance && CalculateDistance() <= m_chaseDistance) {
                m_fsmState = FSMState.Chase;
            //大于追逐距离,巡逻
            } else if(CalculateDistance() > m_chaseDistance) {
                m_fsmState = FSMState.Patrol;
            }
        }

        private void UpdateDeadState() {

        }

        /// <summary>
        /// 画和玩家之间的线
        /// </summary>
        private void DrawLine(Color color) {
            iTween.DrawLine(new Transform[] { transform,m_player.transform },color);
        }

        /// <summary>
        /// 显示玩家的距离
        /// </summary>
        private void DisplayDistance() {
            float distance = Vector3.Distance(transform.position,m_player.position);
            m_text.text = "State:"+m_fsmState+"
Distance:"+ distance.ToString();
        }

        /// <summary>
        /// 计算和玩家的距离
        /// </summary>
        private float CalculateDistance() {
            return Vector3.Distance(transform.position,m_player.position);
        }
        
        /// <summary>
        /// 是否到达路标
        /// </summary>
        private bool IsArrived() {
            float distance = Vector3.Distance(transform.position,m_waypoints[m_targetWaypointIndex].position);
            if(distance < 0.1f) {
                m_targetWaypointIndex++;
                m_targetWaypointIndex = m_targetWaypointIndex % 4;
                return true;
            }
            return false;
        }

        private void Move(Transform target) {
            transform.LookAt(target);
            transform.Translate(transform.forward * Time.deltaTime * m_moveSpeed,Space.World);
        }
    }
}

视频:https://pan.baidu.com/s/1mioIk6c

项目:https://pan.baidu.com/s/1cpc9T8

SlotMachineWeighted

using UnityEngine;
using System.Collections;

public class SlotMachineWeighted : MonoBehaviour {
    
    public float spinDuration = 2.0f;
    public int numberOfSym = 10;
    public GameObject betResult;
    
    private bool startSpin = false;
    private bool firstReelSpinned = false;
    private bool secondReelSpinned = false;
    private bool thirdReelSpinned = false;
    
    private int betAmount = 100;
    
    private int creditBalance = 1000;
    private ArrayList weightedReelPoll = new ArrayList();    
    private int zeroProbability = 30;
    
    private int firstReelResult = 0;
    private int secondReelResult = 0;
    private int thirdReelResult = 0;
    
    private float elapsedTime = 0.0f;
    
    // Use this for initialization
    void Start () {
        betResult.GetComponent<GUIText>().text = "";
        
        for (int i = 0; i < zeroProbability; i++) {
            weightedReelPoll.Add(0);        
        }
        
        int remainingValuesProb = (100 - zeroProbability)/9;
        
        for (int j = 1; j < 10; j++) {
            for (int k = 0; k < remainingValuesProb; k++) {
                weightedReelPoll.Add(j);
            }
        }
    }
    
    void OnGUI() {
        
        GUI.Label(new Rect(150, 40, 100, 20), "Your bet: ");
        betAmount = int.Parse(GUI.TextField(new Rect(220, 40, 50, 20), betAmount.ToString(), 25));        
        
        GUI.Label(new Rect(300, 40, 100, 20), "Credits: " + creditBalance.ToString());
        
        if (GUI.Button(new Rect(200,300,150,40), "Pull Lever")) {
            betResult.GetComponent<GUIText>().text = "";            
            startSpin = true;
        }
    }
    
    void checkBet() {
        if (firstReelResult == secondReelResult && secondReelResult == thirdReelResult) {
            betResult.GetComponent<GUIText>().text = "JACKPOT!";
            creditBalance += betAmount * 50;
        }
        else if (firstReelResult == 0 && thirdReelResult == 0) {            
            betResult.GetComponent<GUIText>().text = "YOU WIN " + (betAmount/2).ToString();
            creditBalance -= (betAmount/2);
        }
        else if (firstReelResult == secondReelResult) {            
            betResult.GetComponent<GUIText>().text = "AWW... ALMOST JACKPOT!";
        }
        else if (firstReelResult == thirdReelResult) {            
            betResult.GetComponent<GUIText>().text = "YOU WIN " + (betAmount*2).ToString();
            creditBalance -= (betAmount*2);
        }
        else {
            betResult.GetComponent<GUIText>().text = "YOU LOSE!";
            creditBalance -= betAmount;
        }
    }
    
    // Update is called once per frame
    void FixedUpdate () {        
        if (startSpin) {
            elapsedTime += Time.deltaTime;
            int randomSpinResult = Random.Range(0, numberOfSym);
            if (!firstReelSpinned) {
                GameObject.Find("firstReel").GetComponent<GUIText>().text = randomSpinResult.ToString();
                if (elapsedTime >= spinDuration) {
                    int weightedRandom = Random.Range(0, weightedReelPoll.Count);    
                    GameObject.Find("firstReel").GetComponent<GUIText>().text = weightedReelPoll[weightedRandom].ToString();
                    firstReelResult = (int)weightedReelPoll[weightedRandom];
                    firstReelSpinned = true;
                    elapsedTime = 0;
                }
            }
            else if (!secondReelSpinned) {
                GameObject.Find("secondReel").GetComponent<GUIText>().text = randomSpinResult.ToString();
                if (elapsedTime >= spinDuration) {
                    secondReelResult = randomSpinResult;
                    secondReelSpinned = true;
                    elapsedTime = 0;
                }
            }
            else if (!thirdReelSpinned) {
                GameObject.Find("thirdReel").GetComponent<GUIText>().text = randomSpinResult.ToString();
                if (elapsedTime >= spinDuration) {                        
                    if ((firstReelResult == secondReelResult) &&
                        randomSpinResult != firstReelResult) {
                        //the first two reels have resulted the same symbol
                        //but unfortunately the third reel missed
                        //so instead of giving a random number we'll return a symbol which is one less than the other 2
                        
                        randomSpinResult = firstReelResult - 1;
                        if (randomSpinResult < firstReelResult) randomSpinResult = firstReelResult - 1;
                        if (randomSpinResult > firstReelResult) randomSpinResult = firstReelResult + 1;
                        if (randomSpinResult < 0) randomSpinResult = 0;
                        if (randomSpinResult > 9) randomSpinResult = 9;
                        
                        GameObject.Find("thirdReel").GetComponent<GUIText>().text = randomSpinResult.ToString();    
                        thirdReelResult = randomSpinResult;
                    }
                    else {
                        int weightedRandom = Random.Range(0, weightedReelPoll.Count);    
                        GameObject.Find("thirdReel").GetComponent<GUIText>().text = weightedReelPoll[weightedRandom].ToString();
                        thirdReelResult = (int)weightedReelPoll[weightedRandom];
                    }
                    
                    startSpin = false;
                    elapsedTime = 0;
                    firstReelSpinned = false;
                    secondReelSpinned = false;
                    
                    checkBet();
                }
            }
        }
    }
}

 极简感应器:

 

/*
脚本名称:
脚本作者:
建立时间:
脚本功能:
版本号:
*/
using UnityEngine;
using System.Collections;

namespace VoidGame {

    /// <summary>
    /// 玩家
    /// </summary>
    public class Player : MonoBehaviour {

        /// <summary>
        /// 移动目标
        /// </summary>
        public Transform m_target;

        /// <summary>
        /// 移动速度
        /// </summary>
        public float m_moveSpeed = 10f;

        private void Update() {
            Move();
        }

        /// <summary>
        /// 移动
        /// </summary>
        private void Move() {
            if(Vector3.Distance(transform.position,m_target.position) < 1.0f) {
                return;
            }

            Vector3 position = m_target.position;
            position.y = transform.position.y;

            Quaternion lookQuaternion = Quaternion.LookRotation(position - transform.position);
            transform.rotation = Quaternion.Slerp(transform.rotation,lookQuaternion,0.1f);
            transform.Translate(Vector3.forward * Time.deltaTime * 10);
        }

        private void OnDrawGizmos() {
            iTween.DrawLine(new Vector3[] { transform.position,transform.position + transform.forward });
        }
    }
}

/*
脚本名称:
脚本作者:
建立时间:
脚本功能:
版本号:
*/
using UnityEngine;
using System.Collections;

namespace VoidGame {

    /// <summary>
    /// 鼠标点击指示
    /// </summary>
    public class Target : MonoBehaviour {

        private void Update() {
            if(Input.GetMouseButtonDown(0)) {
                Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                RaycastHit hitInfo;
                if(Physics.Raycast(ray.origin,ray.direction,out hitInfo)) {
                    Vector3 position = hitInfo.point;
                    position.y = 1;
                    transform.position = position;
                }
            }
        }
    }
}

/*
脚本名称:
脚本作者:
建立时间:
脚本功能:
版本号:
*/
using UnityEngine;
using System.Collections;

namespace VoidGame {

    /// <summary>
    /// 漫游
    /// </summary>
    public class Wander : MonoBehaviour {

        /// <summary>
        /// 目标位置
        /// </summary>
        private Vector3 m_targetPosition;
        /// <summary>
        /// 移动速度
        /// </summary>
        private float m_moveSpeed = 5.0f;
        //private float rotSpeed = 2.0f;
        /// <summary>
        /// 移动范围
        /// </summary>
        private float minX, maxX, minZ, maxZ;

        void Start() {
            minX = -20.0f;
            maxX = 20.0f;

            minZ = -20.0f;
            maxZ = 20.0f;

            GetNextPosition();
        }

        void Update() {
            if(Vector3.Distance(m_targetPosition,transform.position) <= 1.0f)
                GetNextPosition();

            Vector3 position = transform.position;
            position.y = 0.5f;

            Quaternion targetRotation = Quaternion.LookRotation(m_targetPosition - position);
            transform.rotation = Quaternion.Slerp(transform.rotation,targetRotation,Time.deltaTime);

            transform.Translate(new Vector3(0,0,m_moveSpeed * Time.deltaTime));
        }

        void GetNextPosition() {
            m_targetPosition = new Vector3(Random.Range(minX,maxX),0.5f,Random.Range(minZ,maxZ));
        }
    }
}

/*
脚本名称:
脚本作者:
建立时间:
脚本功能:
版本号:
*/
using UnityEngine;
using System.Collections;

namespace VoidGame {

    /// <summary>
    /// 感观
    /// </summary>
    public class Sense : MonoBehaviour {

        public Aspect.aspect aspectName = Aspect.aspect.Enemy;

        /// <summary>
        /// 检测频率
        /// </summary>
        public float detectionRate = 1.0f;
        /// <summary>
        /// 距上一次检测经过的时间
        /// </summary>
        protected float elapsedTime = 0.0f;

        /// <summary>
        /// 初始化
        /// </summary>
        protected virtual void Initialise() { }
        /// <summary>
        /// 更新感官
        /// </summary>
        protected virtual void UpdateSense() { }

        void Start() {
            elapsedTime = 0.0f;
            Initialise();
        }
        void Update() {
            UpdateSense();
        }
    }
}

/*
脚本名称:
脚本作者:
建立时间:
脚本功能:
版本号:
*/
using UnityEngine;
using System.Collections;

namespace VoidGame {

    /// <summary>
    /// 视觉
    /// </summary>
    public class Perspective : Sense {

        /// <summary>
        /// 视场角度
        /// </summary>
        public int FieldOfView = 45;
        /// <summary>
        /// 视野距离
        /// </summary>
        public int ViewDistance = 100;

        /// <summary>
        /// 玩家
        /// </summary>
        private Transform playerTrans;
        /// <summary>
        /// 射线方向
        /// </summary>
        private Vector3 rayDirection;

        protected override void Initialise() {
            playerTrans = GameObject.FindGameObjectWithTag("Player").transform;
            aspectName = Aspect.aspect.Player;
        }

        protected override void UpdateSense() {
            elapsedTime += Time.deltaTime;

            if(elapsedTime >= detectionRate) {
                //elapsedTime = 0;
                DetectAspect();
            }
        }

        /// <summary>
        /// 检测切面
        /// </summary>
        void DetectAspect() {
            RaycastHit hit;
            //射线方向位从自身到玩家的方向
            rayDirection = playerTrans.position - transform.position;

            //如果自身的朝向和从自身到玩家的方向之间的夹角小于视场角度,射线检测
            if((Vector3.Angle(rayDirection,transform.forward)) < FieldOfView) {
                if(Physics.Raycast(transform.position,rayDirection,out hit,ViewDistance)) {
                    Aspect aspect = hit.collider.GetComponent<Aspect>();
                    if(aspect != null) {
                        if(aspect.aspectName == aspectName) {
                            print("Enemy Detected");
                        }
                    }
                }
            }
        }

        void OnDrawGizmos() {

            //红线连接自身和玩家
            Debug.DrawLine(transform.position,playerTrans.position,Color.red);

            //正前方射线
            Vector3 frontRayPoint = transform.position + (transform.forward * ViewDistance);
            Debug.DrawLine(transform.position,frontRayPoint,Color.green);

            //左前方射线
            Vector3 leftRayPoint = frontRayPoint;
            leftRayPoint.x += FieldOfView * 0.5f;
            Debug.DrawLine(transform.position,leftRayPoint,Color.green);

            //右前方射线
            Vector3 rightRayPoint = frontRayPoint;
            rightRayPoint.x -= FieldOfView * 0.5f;
            Debug.DrawLine(transform.position,rightRayPoint,Color.green);
        }
    }
}

/*
脚本名称:
脚本作者:
建立时间:
脚本功能:
版本号:
*/
using UnityEngine;
using System.Collections;

namespace VoidGame {

    /// <summary>
    /// 切面
    /// </summary>
    public class Aspect : MonoBehaviour {

        /// <summary>
        /// 角色
        /// </summary>
        public enum aspect {
            Player,
            Enemy
        }
        public aspect aspectName;
    }
}

项目:https://pan.baidu.com/s/1i581isP

路径跟随和引导

using UnityEngine;
using System.Collections;

/// <summary>
/// 跟随脚本
/// </summary>
public class VehicleFollowing : MonoBehaviour 
{
    /// <summary>
    /// 路径
    /// </summary>
    public Path path;
    /// <summary>
    /// 速度
    /// </summary>
    public float speed = 20.0f;
    /// <summary>
    /// 质量
    /// </summary>
    public float mass = 5.0f;
    /// <summary>
    /// 是否循环
    /// </summary>
    public bool isLooping = true;

    /// <summary>
    /// 当前速度
    /// </summary>
    private float curSpeed;

    /// <summary>
    /// 当前路径索引
    /// </summary>
    private int curPathIndex;
    /// <summary>
    /// 路径长度
    /// </summary>
    private float pathLength;
    /// <summary>
    /// 目标位置
    /// </summary>
    private Vector3 targetPoint;

    Vector3 velocity;

    void Start () 
    {
        pathLength = path.Length;
        curPathIndex = 0;

        velocity = transform.forward;
    }
    
    // Update is called once per frame
    void Update () 
    {
        
        curSpeed = speed * Time.deltaTime;

        //根据当前路径点索引获取路径的位置
        targetPoint = path.GetPoint(curPathIndex);

        //如果自身位置和目标位置的距离小于路径点的半径,则表示到达位置
        if(Vector3.Distance(transform.position, targetPoint) < path.Radius)
        {
            //如果不是最后一个路径点
            if (curPathIndex < pathLength - 1)
                curPathIndex ++;
            //如果是循环模式,重置下一个路标位置为0
            else if (isLooping)
                curPathIndex = 0;
            //停止
            else
                return;
        }

        if (curPathIndex >= pathLength )
            return;

        if(curPathIndex >= pathLength - 1 && !isLooping)
            velocity += Steer(targetPoint, true);
        else
            velocity += Steer(targetPoint);

        //应用速度
        transform.position += velocity;
        //应用旋转
        transform.rotation = Quaternion.LookRotation(velocity);
    }

    public Vector3 Steer(Vector3 target, bool bFinalPoint = false)
    {
        //计算自身朝向
        Vector3 desiredVelocity = (target - transform.position);
        //获取距离长度
        float dist = desiredVelocity.magnitude;

        //归一化速度
        desiredVelocity.Normalize();

        if (bFinalPoint && dist < 10.0f)
            desiredVelocity *= (curSpeed * (dist / 10.0f));
        else 
            desiredVelocity *= curSpeed;
        
        Vector3 steeringForce = desiredVelocity - velocity; 
        Vector3 acceleration = steeringForce / mass;

        return acceleration;
    }
}

using UnityEngine;
using System.Collections;

public class Path: MonoBehaviour
{
    /// <summary>
    /// 路径点半径
    /// </summary>
    public float Radius = 2.0f;
    /// <summary>
    /// 路径点
    /// </summary>
    public Vector3[] pointA;

    /// <summary>
    /// 路径长度
    /// </summary>
    public float Length
    {
        get
        {
            return pointA.Length;
        }
    }

    public Vector3 GetPoint(int index)
    {
        return pointA[index];
    }

    /// <summary>
    /// Show Debug Grids and obstacles inside the editor
    /// </summary>
    void OnDrawGizmos()
    {
        for (int i = 0; i < pointA.Length; i++)
        {
            if (i + 1 < pointA.Length)
            {
                Debug.DrawLine(pointA[i], pointA[i + 1], Color.red);
            }
        }
    }
}

using UnityEngine;
using System.Collections;

public class VehicleAvoidance : MonoBehaviour 
{
    /// <summary>
    /// 移动速度
    /// </summary>
    public float speed = 20.0f;
    /// <summary>
    /// 质量
    /// </summary>
    public float mass = 5.0f;
    /// <summary>
    /// 力
    /// </summary>
    public float force = 50.0f;
    /// <summary>
    /// 避开障碍的最小距离
    /// </summary>
    public float minimumDistToAvoid = 20.0f;

    /// <summary>
    /// 当前速度
    /// </summary>
    private float curSpeed;
    /// <summary>
    /// 目标位置
    /// </summary>
    private Vector3 targetPoint;

    void Start () 
    {
        mass = 5.0f;        
        targetPoint = Vector3.zero;
    }

    void Update () 
    {
        RaycastHit hit;
        var ray = Camera.main.ScreenPointToRay (Input.mousePosition);

        if(Input.GetMouseButtonDown(0) && Physics.Raycast(ray, out hit, 100.0f))
        {
            targetPoint = hit.point;
        }

        //计算自身朝向
        Vector3 dir = (targetPoint - transform.position);
        //归一化
        dir.Normalize();

        AvoidObstacles(ref dir);

        //判断和目标的距离
        if(Vector3.Distance(targetPoint, transform.position) < 3.0f)
            return;

        curSpeed = speed * Time.deltaTime;

        var rot = Quaternion.LookRotation(dir);
        transform.rotation = Quaternion.Slerp(transform.rotation, rot, 5.0f *  Time.deltaTime);

        transform.position += transform.forward * curSpeed;
    }

    /// <summary>
    /// 避开障碍
    /// </summary>
    public void AvoidObstacles(ref Vector3 dir)
    {
        RaycastHit hit;

        //只检测障碍物层
        int layerMask = 1 << 8;

        if (Physics.Raycast(transform.position, transform.forward, out hit, minimumDistToAvoid, layerMask))
        {
            //获取碰撞点的法向量
            Vector3 hitNormal = hit.normal;
            //不改变y轴
            hitNormal.y = 0.0f;

            //计算新的方向
            dir = transform.forward + hitNormal * force;
        }
    }

    private void OnDrawGizmos() {
        Debug.DrawLine(transform.position,transform.position + transform.forward * minimumDistToAvoid,Color.red);
    }
}

 项目:https://pan.baidu.com/s/1pL0N6OV