2. 程式人生 > >Unity3D 利用FSM設計相機跟隨實現

Unity3D 利用FSM設計相機跟隨實現

阿新 • • 發佈：2019-01-01

筆者介紹：姜雪偉，IT公司技術合夥人，IT高階講師，CSDN社群專家，特邀編輯，暢銷書作者，國家專利發明人;已出版書籍：《手把手教你架構3D遊戲引擎》電子工業出版社和《Unity3D實戰核心技術詳解》電子工業出版社等。

FSM有限狀態機前面已經跟讀者介紹過，使用Unity3D引擎實現了動作狀態以及技能切換，FSM使用的條件是有限個狀態切換，我們可以將FSM應用到相機中，很多人會問在相機中如何使用FSM，不論那種架構其主要目的是將模組之間的耦合性降低，傳統的寫法就是使用一個相機跟隨類，所有的邏輯一股腦的寫在一個類或者兩個類中，這樣一旦邏輯變動，修改起來非常麻煩，可能修改的就不是一個類兩個類的事情，而如果我們採用FSM設計相機跟隨，這樣就容易多了。

接下來就實現FSM有限狀態機，FSM作為一個通用類需要將其設定成模版的方式，具體程式碼如下所示：

using System;
using System.Collections.Generic;

namespace Core
{
    public class FSM
    {
        public class Object<T, K>
            where T : Object<T, K>
        {
            public delegate void Function(T self, float time);

            #region Protected members
            protected TimeSource timeSource = null;
            protected Dictionary<K, State<T, K>> states = new Dictionary<K,State<T,K>>();
            protected State<T, K> state = null;
            protected State<T, K> prevState = null;
            #endregion

            #region Ctors
            public Object()
            {
                timeSource = TimeManager.Instance.MasterSource;
            }

            public Object(TimeSource source)
            {
                timeSource = source;
            }
            #endregion

            #region Public properties
            public K PrevState
            {
                get
                {
                    return prevState.key;
                }
            }

            public K State
            {
                get
                {
                    return state.key;
                }

                set
                {
                    prevState = state;

                    if (prevState != null)
                        prevState.onExit(this as T, timeSource.TotalTime);

                    State<T, K> nextState;
                    if (states.TryGetValue(value, out nextState))
                    {
                        state = nextState;
                        state.onEnter(this as T, timeSource.TotalTime);
                    }
                    else
                    {
                        state = null;
                    }
                }
            }

            public TimeSource TimeSource
            {
                get
                {
                    return timeSource;
                }
                set
                {
                    timeSource = value;
                }
            }
            #endregion

            #region Public methods
            public void AddState(K key, Function onEnter, Function onExec, Function onExit)
            {
                State<T, K> newState = new State<T, K>();

                newState.key = key;
                newState.onEnter = onEnter;
                newState.onExec = onExec;
                newState.onExit = onExit;

                states.Add(key, newState);
            }

            public void Update()
            {
                if (null == state) return;

                state.onExec(this as T, timeSource.TotalTime);
            }
            #endregion
        }

        public class State<T, K>
            where T : Object<T, K>
        {
            public K key;
            public Object<T, K>.Function onEnter;
            public Object<T, K>.Function onExec;
            public Object<T, K>.Function onExit;
        }
    }
}
在這個類中有三部分最重要，第一部分是定義了狀態類，它實現了狀態的切換函式，onEnter，onExec，onExit，這個是作為狀態切換使用的。程式碼如下：
        public class State<T, K>
            where T : Object<T, K>
        {
            public K key;
            public Object<T, K>.Function onEnter;
            public Object<T, K>.Function onExec;
            public Object<T, K>.Function onExit;
        }
另一個類的函式是增加狀態函式，這個需要在Start函式中去執行的，函式程式碼如下所示：
            public void AddState(K key, Function onEnter, Function onExec, Function onExit)
            {
                State<T, K> newState = new State<T, K>();

                newState.key = key;
                newState.onEnter = onEnter;
                newState.onExec = onExec;
                newState.onExit = onExit;

                states.Add(key, newState);
            }
最後一個函式就是Update函式，需要每幀去檢測執行狀態，函式如下所示：
            public void Update()
            {
                if (null == state) return;

                state.onExec(this as T, timeSource.TotalTime);
            }
這三個是最重要的，必須要有的，接下來編寫掛接到物件上的類FiniteStateMachine類指令碼，程式碼如下所示：
using System;
using System.Collections.Generic;
using UnityEngine;
using Core;

public class FiniteStateMachine : MonoBehaviour
{
	public enum UpdateFunction
	{
		Update = 0,
		LateUpdate,
		FixedUpdate
	}
	
	#region Public classes
	public class FSMObject : FSM.Object<FSMObject, int>
	{
		public GameObject go;
		
		public FSMObject(GameObject _go)
		{
			go = _go;
		}
	}
	
	[Serializable]
	public class StateType
	{
		public int id;
		public string onEnterMessage;
		public string onExecMessage;
		public string onExitMessage;
		
		public void onEnter(FSMObject fsmObject, float time)
		{
			fsmObject.go.SendMessage(onEnterMessage, time, SendMessageOptions.RequireReceiver);
		}
		
		public void onExec(FSMObject fsmObject, float time)
		{
			fsmObject.go.SendMessage(onExecMessage, time, SendMessageOptions.RequireReceiver);
		}
		
		public void onExit(FSMObject fsmObject, float time)
		{
			fsmObject.go.SendMessage(onExitMessage, time, SendMessageOptions.RequireReceiver);
		}
	}
	#endregion
	
	#region Public members
	public bool manualUpdate = false;
	public UpdateFunction updateFunction = UpdateFunction.Update;
	public StateType[] states;
	public int startState;
	#endregion
	
	#region Protected members
	protected FSMObject fsmObject = null;
	#endregion
	
	#region Public properties
	public int PrevState
	{
		get
		{
			return fsmObject.PrevState;
		}
	}
	
	public int State
	{
		get
		{
			return fsmObject.State;
		}
		set
		{
			fsmObject.State = value;
		}
	}
	
	public TimeSource TimeSource
	{
		get
		{
			return fsmObject.TimeSource;
		}
		set
		{
			fsmObject.TimeSource = value;
		}
	}
	#endregion
	
	#region Public methods
	public void ForceUpdate()
	{
		fsmObject.Update();
	}
	#endregion
	
	#region Unity callbacks
	protected void Start()
	{
		fsmObject = new FSMObject(gameObject);
		foreach (StateType state in states)
			fsmObject.AddState(state.id, state.onEnter, state.onExec, state.onExit);
		fsmObject.State = startState;
	}
	
	void Update()
	{
		//Debug.Log ("update");
		if (manualUpdate)
			return;
		
		if (UpdateFunction.Update == updateFunction)
			fsmObject.Update();
	}
	
	void LateUpdate()
	{
		if (manualUpdate)
			return;
		
		if (UpdateFunction.LateUpdate == updateFunction)
			fsmObject.Update();
	}
	
	void FixedUpdate()
	{
		if (manualUpdate)
			return;
		
		if (UpdateFunction.FixedUpdate == updateFunction)
			fsmObject.Update();
	}
	#endregion
}
該函式需要掛接到物件上，效果如下所示：



以上就是我們所封裝的FSM有限狀態機，接下來在專案中使用我們的FSM，先實現最基本的邏輯類如下所示：

using System;
using System.Collections.Generic;
using UnityEngine;
public class FollowCharacter : MonoBehaviour
{
	public GameObject player;
	public Vector3 sourceOffset = new Vector3(0.0f, 2.5f, -3.4f);
	public Vector3 targetOffset = new Vector3(0.0f, 1.7f, 0.0f);
	
	protected bool firstFrame;
	protected float currHeightSmoothing;
	
	protected float groundHeightTest;
	protected bool slideshowActive = false;
	protected float slideshowEnterTime = 0.0f;
	protected float slideshowExitTime = 0.0f;
	
	protected bool oldCameraActive = true;
	
	protected float oldFov = 70.0f;
	protected Vector3 oldCamSourceOffset = new Vector3(0.0f, 8.5f, -4.5f);
	protected Vector3 oldCamTargetOffset = new Vector3(0.0f, 0.9f, 5.3f);
	
	protected int cameraIndex = 3;
	protected float[] cameraFovs = { 55.0f, 60.0f, 55.0f };
	protected Vector3[] cameraSourceOffsets = {
		new Vector3(0.0f, 5.8f, -3.8f),
		new Vector3(0.0f, 6.04f, -4.0f),
		new Vector3(0.0f, 8.5f, -6.7f)
	};
	protected Vector3[] cameraTargetOffsets = {
		new Vector3(0.0f, 2.2f, 2.5f),
		new Vector3(0.0f, 1.35f, 3.36f),
		new Vector3(0.0f, 1.45f, 5.3f)
	};
	protected Vector3 newCamSourceOffset = new Vector3(0.0f, 6.04f, -4.0f);//Camera 2
	protected Vector3 newCamTargetOffset = new Vector3(0.0f, 1.35f, 3.36f);//Camera 2

	protected Vector3 testNewTurboSourceOffset = new Vector3(0.0f, 5.8f, -4.0f);
	protected Vector3 testNewTurboTargetOffset = new Vector3(0.0f, 2.1f, 2.5f);
	protected Vector3 testNewFinalSourceOffset = new Vector3(-6.5f, 5.0f, -5.5f);
	protected Vector3 testNewFinalTargetOffset = new Vector3(-4.5f, 1.7f, 0.0f);

	#region public Classes
	public class ShakeData
	{
		public float duration;
		public float noise;
		public float smoothTime;
		
		public ShakeData(float _duration, float _noise, float _smoothTime)
		{
			duration = _duration;
			noise = _noise;
			smoothTime = _smoothTime;
		}
	}
	#endregion
	
	public void OnFollowCharaEnter(float time)
	{
		prevPlayerPivot = player.transform.position;
		firstFrame = true;
		currHeightSmoothing = heightSmoothing;
		deadTime = -1.0f;
		actionTaken = false;
	}
	
	public void OnFollowCharaExec(float time)
	{
		if (player == null)
			return;

		float dt = Time.fixedDeltaTime;
		float now = TimeManager.Instance.MasterSource.TotalTime;
		Vector3 playerPivot = player.transform.position;
		playerPivot.x = 0.0f;
		playerPivot.y = 0.0f;
		
		float targetHeight = playerPivot.y;
		
		if (firstFrame)
		{
			lastPivotHeight = targetHeight;
			prevPlayerPivot = playerPivot;
			heightVelocity = 0.0f;
			firstFrame = false;
		}
		else
		{
			float targetSmoothTime = 0.1f;
			
			smoothTime = Mathf.MoveTowards(smoothTime, targetSmoothTime, 2.5f * dt);
			
			lastPivotHeight = Mathf.SmoothDamp(lastPivotHeight, targetHeight, ref heightVelocity, smoothTime, 50.0f, dt);
			prevPlayerPivot = playerPivot;
		}
		Vector3 camPivot = new Vector3(prevPlayerPivot.x * 0.8f, lastPivotHeight, prevPlayerPivot.z);

		lastSourceOffset = this.EaseTo(lastSourceOffset, goalSourceOffset, sourceOffset);
		lastTargetOffset = this.EaseTo(lastTargetOffset, goalTargetOffset, targetOffset);
		
		transform.position = camPivot + lastSourceOffset + offset * 0.1f + noise * noiseStrength; // +noise * noiseStrength + noiseTremor * 0.00069f * kinematics.PlayerRigidbody.velocity.z; //PIETRO
		
		transform.LookAt(camPivot + lastTargetOffset + offset * 0.1f, Vector3.up);
		
		if (!TimeManager.Instance.MasterSource.IsPaused)
		{
			//Camera Shake
			if (shakeCameraActive)
				ShakeCamera(dt);
			
			//tremor (always active
			this.UpdateTremor(dt);
		}
		
		//check if is dead
		if (now - deadTime > 3.6f && !actionTaken && deadTime > 0.0f)
		{
			actionTaken = true;
			//Debug.Log("GO TO REWARD");
			LevelRoot.Instance.BroadcastMessage("GoToOffgame");     //GoToReward");
		}
	}
	
	public void OnFollowCharaExit(float time)
	{
	}
	
	void OnReset()
	{
		//Debug.Log("RESET CAM");
		interpolating = false;
		shakeCameraActive = false;
		sourceOffset = defaultSourceOffset;
		targetOffset = defaultTargetOffset;
	}
	
	void ShakeCamera(float deltaTime)
	{
		if (TimeManager.Instance.MasterSource.TotalTime - shakeStartTime <= currentShakeData.duration)
		{
			if (currentShakeData.smoothTime > 0.0f)
				noiseStrength = Mathf.SmoothDamp(noiseStrength, currentShakeData.noise, ref noiseStrengthVel, currentShakeData.smoothTime, 300.0f, deltaTime);
			else
				noiseStrength = currentShakeData.noise; // go directly
			
			if (noiseStrength > 0.0f)
			{
				Vector3 v = UnityEngine.Random.onUnitSphere;
				noise += (v - noise) * deltaTime * 8.0f;
			}
			else
				noise = SRVector3.zero;
		}
		
		if (TimeManager.Instance.MasterSource.TotalTime - shakeStartTime >= currentShakeData.duration)
			StopShakeCamera();
	}
	
	void StopShakeCamera()
	{
		currentShakeData = new ShakeData(0.0f, 0.0f, 0.0f);
		noiseStrength = 0.0f;
		noise = SRVector3.zero;
		shakeCameraActive = false;
	}
	
	public string ChangeCamera()
	{
		string buttonText = "";
		buttonText = cameraIndex == 0 ? "Old camera on" : "camera " + cameraIndex + " on";
		if (cameraIndex == 0)
		{
			gameObject.GetComponent<Camera>().fieldOfView = oldFov;
			lastSourceOffset = defaultSourceOffset = sourceOffset = oldCamSourceOffset;
			lastTargetOffset = defaultTargetOffset = targetOffset = oldCamTargetOffset;
			goalSourceOffset = oldCamSourceOffset;
			goalTargetOffset = oldCamTargetOffset;
		}
		else
		{
			gameObject.GetComponent<Camera>().fieldOfView = cameraFovs[cameraIndex - 1];
			lastSourceOffset = defaultSourceOffset = sourceOffset = cameraSourceOffsets[cameraIndex - 1];
			lastTargetOffset = defaultTargetOffset = targetOffset = cameraTargetOffsets[cameraIndex - 1];
			goalSourceOffset = cameraSourceOffsets[cameraIndex - 1];
			goalTargetOffset = cameraTargetOffsets[cameraIndex - 1];
		}
		
		return buttonText;
	}
}

其中指令碼中加粗的函式是有限狀態機執行的具體邏輯。。。。。。。另外其他的變數宣告和函式實現是根據策劃需求新增的，讀者只需要關注加粗的函式實現就可以了。
附圖如下所示：



相關推薦

Unity3D 利用FSM設計相機跟隨實現

筆者介紹：姜雪偉，IT公司技術合夥人，IT高階講師，CSDN社群專家，特邀編輯，暢銷書作者，國家專利發明人;已出版書籍：《手把手教你架構3D遊戲引擎》電子工業出版社和《Unity3D實戰核心技術詳解》電子工業出版社等。FSM有限狀態機前面已經跟讀者介紹過，使用Unity3D引

Unity3d利用A*尋路演算法實現尋路模擬

這裡我先引用一篇詳細文章來介紹A*演算法文章內容如下簡易地圖 如圖所示簡易地圖, 其中綠色方塊的是起點 (用 A 表示), 中間藍色的是障礙物, 紅色的方塊 (用 B 表示) 是目的地. 為了可以用一個二維陣列來表示地圖, 我們將地圖劃分成一個個的小方塊.二維陣列在遊戲中的應

Unity3d--實現第三人稱視角（相機跟隨）

實現第三人稱視角有三種： 方案1： 最簡單的就是 直接 把主相機作為Player角色的子物體，並自行固定好相機的位置 方案2： 設定一個空的GameObject，並且與Player的旋轉和位置保持一致，然後將 主相機 設定成該GameObject的子

unity3D：遊戲分解之角色移動和相機跟隨

ini img form static 錄像 void 方法 lda okr 遊戲中，我們經常會有這樣的操作，點擊場景中某個位置，角色自動移動到那個位置，同時角色一直是朝向那個位置移動的，而且相機也會一直跟著角色移動。有些遊戲，鼠標滑動屏幕，相機就會圍繞角色旋

吃雞（遙杆）人物移動及相機跟隨的實現

抽空做的一個小Demo,基本功能還是能實現的。  1.左下遙杆控制移動 2.右下區域遙杆控制人物轉向及相機跟隨轉向 3.右上遙杆控制視野（相機角度） 懶省事，基本能省事就省事了，物體都是拖拽。   照著拖就行了 左下遙杆  /// <

Unity3D 利用C#實現簡單的代理模式Delegate（委託）

Ref: http://www.cnblogs.com/shadow7/p/5892641.html 1、Delegate是什麼？ Delegate中文翻譯為“委託”。 C#語言是支援代理的，

cocos creator~實現相機跟隨

1）建立一個攝像機 Camera影響的節點是game節點，這個節點下面有hero和整個tiled地圖 2）將要跟隨的物體，即hero的座標轉化為相機的座標，注意：只想跟隨x軸 cc.Class({ extends: cc.Component, propert

Unity3D利用Photon實現實時聯網對戰（一）Photon Server介紹

Photon 是一個實時多人遊戲開發框架,它是快速、精益和靈活的。 Photon伺服器功能強大，能夠滿足一般的中小型網路遊戲的需求，而且開發效率高，所以就稱為了大多數開發者的首選。由於網上關於Photon聯網的介紹內容比較少，現在小義就跟大家分享一下關於Pho

Unity 實現簡單的相機跟隨和滑鼠滾輪拉近拉遠視野

1.指令碼掛載在Main Camera 上 ，相機跟隨的實現主要是讓相機的位置和玩家的位置的差值始終保持不變。2.實現滑鼠滾輪拉近拉遠視野，要先測試一下自己滑鼠滾輪前滑後滑的正負值，每個滑鼠不一定相同。using System.Collections; using Syste

Unity3D利用Photon實現實時聯網對戰（二）PUN SDK介紹

由於這段時間公司的專案有點忙，好久沒有更新啦，在這裡希望得到大家的諒解，好了，廢話不多說啦，直奔主題！ 今天的介紹內容是PUN SDK的運用，主要通過官方Demo來一起學習。 1、配置Photon Server伺服器

Unity3d相機跟隨角色移動

using UnityEngine; using System.Collections; public class follwCam : MonoBehaviour { public Transf

Unity3d 利用Mesh繪製幾何圖形實現

一、建立一個GameObject,並在上面掛兩個元件(MeshFilter、MeshRenderer) 二、新建個指令碼，並掛在剛才建立的GameObject上     using UnityEngine;    using System.Collections; 

利用【mapreduce】來實現——【wordcount的設計思路】

1.wordcount示例開發 map階段：將每行文字資料變成<單詞，1>這樣的k,v資料 reduce

利用微設計實現可持續高效的基礎設施

瞭解微設計基礎架構（MDI）的概念，它們如何幫助開發，以及它們與DevOps和微服務等技術的關係。 技術決策既困難又嚴肅，可以決定專案的成敗。如何找到合適的技術棧？“微設計基礎架構”（MDI）是一種新方法，它使用“設計思維”中的回憶來開發最佳，易於理解且是公司範圍內公認的基礎架構或技術堆疊。 技術和基礎設施決

設計模式C++實現——工廠方法模式

對象 類型 begin 創建對象 dia rate rod rtu log 模式定義： 工廠方法模式定義了一個創建對象的接口，但由子類決定要實例化的類是哪一個。工廠方法讓類把實例化推遲到子類。 模式結構： Creator是一個類，它

利用jQuery設計橫/縱向菜單

cor 清晰 down content img javascrip ogg 當我 菜單 在網頁中，菜單扮演著“指路者”的角色。怎樣設計一個人性化的菜單呢。以下小編帶著大家一起做。 效果圖： 設計歷程： 1.首先利用html中的<ul>和&l

python+opencv選出視頻中一幀再利用鼠標回調實現圖像上畫矩形框

open cap 圖像 ide http 這樣的 vedio lease 等待 　　最近因為要實現模板匹配，需要在視頻中選中一個目標，然後框出（即作為模板），對其利用模板匹配的方法進行檢測。於是需要首先選出視頻中的一幀，但是在利用攝像頭讀視頻的過程中我唯一能想到的方法就是：

大話設計模式C++實現-第17章-適配器模式

req span oid efi cpp endif 對象 adapt sdn 一、UML圖 關鍵詞：Client須要Request（）函數，Adaptee提供的是SpecificRequest（）函數，Adapter提供一個Request（）函數將Ada

PHP中利用PHPMailer配合QQ郵箱實現發郵件

一定的 bst strong ddr 實驗室 ber 希望 域名 add 前言： 由於作業的需要，要實現給我們的網站用戶發送郵件，於是就有了這篇博客。以下的內容是我結合網上的例子加上自己的實踐的出來的。希望對大家有幫助。 PHPMailer的介紹： 優點： 可運行在任何平

在Unity3D項目中接入ShareSDK實現安卓平臺微信分享功能（可使用ShareSDK默認UI或自定義UI）

顯示 選項 dev template 腳本 配置文件 all 自己 show 　　最近公司的大廳要重做，我協助主程一起制作新大廳和新框架，前面制作的編輯器也派上了用場。等全部功能做完後我會再寫一個復盤，這兩天主程在忙於寫熱更新的功能，所以把接入分享SDK功能的任務交給了我，