Unity中3D场景中一些使用方法（为自己）

Unity 3D场景中的模型 和 角色名字保持相对位置

using UnityEngine;
using System.Collections;

public class NamePanel : MonoBehaviour
{
[SerializeField]
UILabel lblName;

[SerializeField]
GameObject obj;

[SerializeField]
Camera mainCamera;

[SerializeField]
Camera uiCamera;

void Update()
{
UpdateNamePosition();
}

Vector3 m_position;
/// <summary>
/// 更新名字位置
/// </summary>
void UpdateNamePosition()
{
//取模型在主摄像机中的世界坐标
m_position = obj.transform.position;
//转换为主摄像机的屏幕坐标
m_position = mainCamera.WorldToScreenPoint(m_position);
//用得到的屏幕坐标，在UI摄像机中转换为世界坐标
m_position = uiCamera.ScreenToWorldPoint(m_position);
m_position.z = 0f;
m_position.y += 0.1f;
lblName.transform.position = m_position;
}
}

给摄像机添加一个Look At Target脚本，并将其Target设为人物。

接着自己写一个脚本Camera Round，拖给摄像机，让摄像机绕着人物旋转。

using UnityEngine;

using System.Collections;

public class cameraRound : MonoBehaviour {

public GameObject hero;

void Update () {

gameObject.transform.RotateAround(hero.transform.position,Vector3.up,0.1f);

}

}

using UnityEngine;

using System.Collections;

public class blood_bar : MonoBehaviour {

public GameObject _bloodBar;//获取血条信息。

public GameObject MainCamera;//获取主摄像机

void Update () {

_bloodBar.transform.position=new Vector3(transform.position.x,transform.position.y+2.0f,transform.position.z);//让血条信息一直处于人物的头顶某处

Vector3 v=transform.position-MainCamera.transform.position;

Quaternion rotation;

rotation = Quaternion.LookRotation(v);

_bloodBar.transform.rotation = rotation;//让血条一直面向摄像机。由于摄像机是以人物为目标的，所以v应该为人物的位置到摄像机位置的向量，否则信息栏会出现偏差。

}

}

//################## 简单的AI处理 #############

Enemy_AI.js

private var Regression : Vector3;

public var Player_Prefab : Transform;

public var Enemy_State : String;

public var Doing : boolean = true;

public var Range : float = 4.0;

public var Bullet : Transform;

public var Bullet_Prefab : Transform;

//初始化敌人方向和位置

function Start()

{

transform.localEulerAngles.y = Random.value * 360;

Regression = transform.position;

}

//敌人行动模式

public var Thinking : boolean = true;

public var Thinking_Time : float = 1.0;

private var relativePos : Vector3;

private var rotation : Quaternion;

public var Facing : boolean = false;

public var Facing_Time : float = 2.0;

public var Facing_Speed : float = 2.0;

public var Moving : boolean = false;

public var Moving_Speed : float = 0.5;

public var Moving_Time : float = 4.0;

public var Moving_Back : boolean = false;

public var Attacking : boolean = false;

private var Bullet_DO : boolean = true;

public var Bullet_CD : float = 0.2;

//随机移动方位

private var R_Position : Vector3;

function Update ()

{

if(Attacking)

{

Enemy_State = "Attacking";

Facing = true;

Moving = true;

//Doing = true;

Thinking = false;

var dist2 = Vector3.Distance(Regression, transform.position);

if(dist2 > 20)

{

relativePos = Regression - transform.position;

rotation = Quaternion.LookRotation(relativePos);

Attacking = false;

Moving_Back = true;

}

}

if(!Moving_Back)

{

var dist = Vector3.Distance(Player_Prefab.position, transform.position);

if(dist > 100)

{

Attacking = false;

return;

}

else if(dist < 5)

{

Attacking = true;

}

RayJudge();

}

transform.localEulerAngles.x = 0;

transform.localEulerAngles.z = 0;

if(Thinking && !Attacking && !Moving_Back)

{

Enemy_State = "Thinking";

if(Doing)

{

StartCoroutine(Think(Thinking_Time));

Doing = false;

}

}

if(Facing)

{

Enemy_State = "Facing";

if(Attacking)

{

relativePos = Player_Prefab.position - transform.position;

rotation = Quaternion.LookRotation(relativePos);

transform.rotation = Quaternion.Slerp(transform.rotation, rotation, Time.deltaTime * Facing_Speed * 4);

}

else if(Moving_Back)

{

transform.rotation = Quaternion.Slerp(transform.rotation, rotation, Time.deltaTime * Facing_Speed * 4);

}

else

{

transform.rotation = Quaternion.Slerp(transform.rotation, rotation, Time.deltaTime * Facing_Speed);

if(Doing)

{

StartCoroutine(Face(Facing_Time));

Doing = false;

}

}

}

if(Moving)

{

Enemy_State = "Moving";

if(Moving_Back)

{

transform.Translate(Vector3.forward * Time.deltaTime * Moving_Speed * 6);

}

else if(dist > 2)

{

if(Attacking)

{

transform.Translate(Vector3.forward * Time.deltaTime * Moving_Speed * 4);

}

else

{

transform.Translate(Vector3.forward * Time.deltaTime * Moving_Speed);

}

}

if(Doing && !Attacking)

{

StartCoroutine(Move(Moving_Time));

Doing = false;

}

}

}

//前方锁敌

function RayJudge()

{

var layerMask = 1 << 2;

layerMask = ~layerMask;

var hit : RaycastHit;

if(Physics.Raycast (transform.position, transform.TransformDirection(Vector3.forward), hit, 20,layerMask))

{

var distanceToForward = hit.distance;

if(hit.transform.tag == "Player")

{

Attacking = true;

if(Bullet_DO)

{

var Create = Instantiate (Bullet_Prefab, Bullet.position, Quaternion.identity);

Create.rigidbody.AddForce (Bullet.forward * 1000);

StartCoroutine(Wait(Bullet_CD));

Bullet_DO = false;

}

}

}

}

function Wait(waitTime : float)

{

yield WaitForSeconds (waitTime);

Bullet_DO = true;

}

function Move(waitTime : float)

{

print("Move");

if(Moving_Back)

{

yield WaitForSeconds (waitTime * 0.4);

}

else

{

yield WaitForSeconds (waitTime + Random.value * 2);

}

Thinking = true;

Moving_Back = false;

Moving = false;

Facing = false;

Doing = true;

}

function Face(waitTime : float)

{

print("Face");

yield WaitForSeconds (waitTime + Random.value);

Facing = false;

Thinking = false;

Moving = true;

Doing = true;

}

function Think(waitTime : float)

{

print("Thinking");

yield WaitForSeconds (waitTime + Random.value);

R_Position = Regression + Random.insideUnitSphere * Range;

R_Position.y = Regression.y;

relativePos = R_Position - transform.position;

rotation = Quaternion.LookRotation(relativePos);

Thinking = false;

Moving = false;

Facing = true;

Doing = true;

}

//#############################

//#################### 射线点击 实现鼠标控制 旋转和移动 #######################

private bool flagMove;

private RaycastHit hit;

private Vector3 mousePos;

private Vector3 targetDir;

// Use this for initialization

void Start()

{ flagMove = false; }

void Update()

{

if (Input.GetMouseButtonDown(0))

{ RayControl(); }

if (flagMove)

{

if (Vector3.Distance(transform.position, mousePos) > 0.1)

{ transform.Translate(transform.worldToLocalMatrix * transform.right * Time.deltaTime * 0.5f); }

else

{

flagMove = false;

}

}

}

void RayControl()

{

Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);//从Camera发射射线到屏幕

if (Physics.Raycast(ray, out hit))//射线碰撞检测

{

mousePos = hit.point;

mousePos.z = transform.position.z;

targetDir = mousePos - transform.position;//计算到目标点的方向

Vector3 tempDir = Vector3.Cross(transform.right, targetDir.normalized);

float dotValue = Vector3.Dot(transform.right, targetDir.normalized);

float angle = Mathf.Acos(dotValue) * Mathf.Rad2Deg;//计算夹角

if (tempDir.z < 0)//根据叉乘判断夹角的正负

{ angle = angle * (-1); }

if (!float.IsNaN(angle))

{

transform.RotateAround(transform.position, Vector3.forward, angle);//转向目标点

}

flagMove = true;

}

}

//##################################################################################

//##############################

//################################################################

#