U3D小项目参考
《U3D小项目参考》
++U3D小案例简述
++++这里是立钻哥哥汇总的几个U3D小案例，通过案例学习U3D的基本编程和技巧。
++++小案例会不断更新补充，通过学习掌握U3D的编程和思想。
++小案例目录：
++++小案例001、贪吃蛇Demo
++++小案例002、飞机大战Demo
++++小案例003、MVC框架（提升等级案例）
++++小案例004、简单背包案例
++++小案例005、塔防Demo
++++小案例006、秘密行动Demo
++++小案例007、A_Star
++++小案例008、血条LiftBar跟随
++++小案例009、见缝插针StickPin
++++小案例010、UnityNetDemo
++++小案例011、SocketFileRecv
++++小案例012、切水果CutFruitDemo
++++小案例013、吃鸡_友军方位UV
++++小案例014、数据库背包SqliteEZ_Bag
++++小案例015、Json数据存储
++++小案例016、关卡系统LevelSystem
++++超级Demo：斗地主
#小案例001、贪吃蛇demo
++小案例001：贪吃蛇demo
++++Cube_Snake_Body.prefab
++++Cube_Snake_Food.prefab
++++Scene02Snake.unity
++++SnakeMoveScript.cs
###SnakeMoveScript.cs
（C:\000-ylzServ_U3D_Pro\小案例001\Assets\DemoSnake\SnakeMoveScript.cs）
++SnakeMoveScript.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
using UnityEngine.SceneManagement; //引入场景控制器
public class SnakeMoveScript : MonoBehaviour{
/*
蛇头移动：
#1、蛇头移动（默认方向朝上，wsad控制移动）
#2、生成食物（随机生成）
#3、吃到食物后生成蛇身
#4、游戏结束
*/
//1、蛇头移动（默认方向朝上，wsad控制移动）
Vector2 dirV2Move = Vector2.up; //默认向上移动
public float speedMoveRate= 5f; //速度
public GameObject snakeBody; //身体
public GameObject snakeFood; //食物
//创建集合存放身体（蛇身）
List<Transform> bodyList = new List<Transform>();
bool isCreate = false; //控制是否创建身体
//Use this for initialization
void Start(){
for(int i =0; i <5; i++){
Invoke(“CreatFood”,1.0f); //延迟1秒，调用Creat
}
//在游戏开始1.5秒调用Move方法，然后每隔0.2秒再重复调用
InvokeRepeating(“SnakeMove”,1.5f, 0.2f); //每几秒重复调用这个函数
}
//Update is called once per frame
void Update(){
dirV2Move = GetMoveDir(); //获取控制方向
}
//触发检测
void OnTriggerEnter(Collider other){
if(other.gameObject.CompareTag(“SnakeFood”)){
//如果碰撞到的是食物
Destroy(other.gameObject); //销毁食物
isCreate = true;
Invoke(“CreatFood”,0.3f); //0.3秒之后创建食物
}else if(other.gameObject.CompareTag(“SnakeBody”)){
//碰到自己
Debug.Log(“yanlzPrint:碰到自己身体了，游戏结束！”);
//todo优化碰到自己身体处理事件
}else{
Debug.Log(“yanlzPrint：碰到墙了，游戏重新开始！”);
SceneManager.LoadScene(“Scene02Snake”); //重新加载场景（新一局）
}
}
//自定义函数
//获取方向控制
//1、蛇头移动（默认方向朝上，wsad控制移动）
Vector2 GetMoveDir(){
if(Input.GetKeyDown(KeyCode.W)){
dirV2Move = Vector2.up;
}else if(Input.GetKeyDown(KeyCode.S)){
dirV2Move = Vector2.down;
}else if(Input.GetKeyDown(KeyCode.A)){
dirV2Move = Vector2.left;
}else if(Input.GetKeyDown(KeyCode.D)){
dirV2Move = Vector2.right;
}
return dirV2Move;
}
//生成食物
void CreatFood(){
Vector3 foodPosV3 = new Vector3(Random.Range(-14,14),Random.Range(-14,14),0);
Instantiate(snakeFood,foodPosV3,Quaternion.identity);
}
//移动方法
void SnakeMove(){
Vector3 curPos= transform.position; //移动之前，首先记录蛇头位置
//创建蛇身
if(isCreate == true){
//创建身体
Vector3 createBodyPosV3 = curPos; //在蛇头位置创建
GameObject createBodyObj;
createBodyObj = Instantiate(snakeBody,createBodyPosV3,Quaternion.identity);
Color colorRandom = new Color(Random.value,Random.value,Random.value);
createBodyObj.GetComponent<MeshRenderer>().material.color = colorRandom;
bodyList.Insert(0,createBodyObj.transform); //将身体插入到集合当中
isCreate = false; //将创建标志置为false
}else if(bodyList.Count>0){
//身体个数大于0
//蛇身最后位置 //当前蛇头位置
bodyList.Last().position = curPos; //更新蛇身位置
//list里面元素进行交换位置，最后一个元素添加到最前面
bodyList.Insert(0, bodyList.Last());
bodyList.RemoveAt(bodyList.Count -1); //移除最后一个元素（因为其已经被加入到第一个位置）
}
transform.Translate(dirV2Move); //改变当前蛇头位置
}
}
#小案例002、耳轮跳（NG进行中）
++小案例002、耳轮跳demo
++++HudText.cs
++++BallFallScript.cs
++++CreateGap.cs
++++CreateRing.cs
++++CreateTrap.cs
++++GameMgr.cs
++++RingInfo.cs
++++RotatePillar.cs
++++SectorInfor.cs
###HudText.cs
（D:\zz_DemoPro()-\小案例002、耳轮跳-HelixJump-\Assets\HudText.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class HudText:MonoBehaviour{
private void Start(){
GameObject.Destroy(gameObject,1f);
}
//下落
private void Update(){
transform.position -= Vector3.up*Time.deltaTime* 0.5f;
GetComponent<CanvasGroup>().alpha -= Time.deltaTime;
}
//设置值
public void SetText(string s){
transform.GetComponentInChildren<Text>().text=s;
}
}
###BallFallScript.cs
（D:\zz_DemoPro()-\小案例002、耳轮跳-HelixJump-\Assets\Project\Scripts\BallFallScript.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class BallFallScript:MonoBehaviour{
float g = -9.8f;
float v = 0;
float timer = 0;
//1m的间距最大速度达到4.4m/s，这里考虑小球和平板的高度，取3.5f，也就是说最大速度为3.5f
float maxV = 3.5f;
public int power =0; //小球势能
public int powerToggle =3; //达到层数，可以获得击碎能力
private void Update(){
Fall();
}
private void Fall(){
v = v + g *Time.delatTime;
v = Mathf.Clamp(v, -maxV, maxV);
transform.position += transform.up*Time.deltaTime*v;
}
private void LateUpdate(){
float y = Camera.main.WorldToScreenPoint(transform.position).y;
if(y /Screen.height<0.7f){
Camera.main.transform.SetParent(transform);
}else{
Camera.main.transform.SetParent(null);
}
}
//碰撞结算
private void OnCollisionEnter(Collision collision){
v =maxV;
Camera.main.transform.SetParent(null);
SectorInfo si =collision.collider.GetComponent<SectorInfo>();
if(power>=powerToggle){
si.transform.parent.GetComponent<RingInfo>().Explosion();
}else if(si.IsTrap&&si.transform.parent.GetComponent<RingInfo>().isBreaken == false){
GameObject.FindObjectOfType<GameMgr>().GameOver();
}
power = 0;
}
}
###CreateGap.cs
（D:\zz_DemoPro()-\小案例002、耳轮跳-HelixJump-\Assets\Project\Scripts\CreateGap.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class CreateGap:MonoBehaviour{
public int minGapGroup=1;
public int maxGapGroup=3;
public int minGap=2;
public int maxGap=4;
MeshCollider[] sectors;
private void Start(){
sectors = GetComponentsInChildren<MeshCollider>()
int group = Random.Range(minGapGroup, maxGapGroup+1);
for(int i =0; i<group; i++){
int pos = Random.Range(0,secotrs.Length);
int gaps = Random.Range(minGap,maxGap+1);
for(int j=0;j <gaps; j++){
sectors[(pos+j) %sectors.Length].gameObject.SetActive(false);
}
}
}
}
###CreateRing.cs
（D:\zz_DemoPro()-\小案例002、耳轮跳-HelixJump-\Assets\Project\Scripts\CreateRing.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class CreateRing:MonoBehaviour{
public GameObject ringPre;
private void Start(){
for(int i = 0; i <100;i++){
GameObject ring = GameObject.Instantiate(ringPre,new Vector3(0, -50+i *1f),Quaternion.identity);
ring.GetComponent<RingInfo>().index = i;
ring.transform.SetParent(transform);
}
}
}
###CreateTrap.cs
（D:\zz_DemoPro()-\小案例002、耳轮跳-HelixJump-\Assets\Project\Scripts\CreateTrap.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class CreateTrap:MonoBehaviour{
public int minTrapGroup = 1;
public int maxTrapGroup =3;
public int minTrap = 2;
public int maxTrap = 4;
MeshCollider[] sectors;
private void Start(){
sectors = GetComponentsInChildren<MeshCollider>();
int group = Random.Range(minTrapGroup,maxTrapGroup+1);
for(int i = 0; i<group;i++){
int pos = Random.Range(0, sectors.Length);
int gaps = Random.Range(minTrap,maxTrap+1);
for(int j=0; j<gaps; j++){
int index = (pos+ j) %sectors.Length;
if(sectors[index].gameObject.activeSelf&&transform.GetComponent<RingInfo>().index<95){
sectors[index].GetComponent<MeshRenderer>.material.color = Color.red;
sectors[index].GetComponent<SectorInfo>.IsTrap=true;
}
}
}
}
}
###GameMgr.cs
（D:\zz_DemoPro()-\小案例002、耳轮跳-HelixJump-\Assets\Project\Scripts\GameMgr.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
public class GameMgr:MonoBehaviour{
//设置分数
public Text scoreText;
public Text levelText;
public Button restartBtn;
public int score=0;
public bool gameOver=false;
priavate void Awake(){
Time.timeScale=0;
Screen.SetResolution(750,1334,false);
}
private void Start(){
restartBtn.onClick.AddListener(GameStart);
restartBtn.gameObject.SetActive(false);
}
public void GameStart(){
SceneManger.LoadScene(“Demo002_HelixJump_Lovezuanzuan”);
}
public void GameOver(){
gameOver = true;
Time.timeScale = 0;
restartBtn.gameObject.SetActive(true);
}
private void Update(){
if(Input.GetMouseButtonDown(0) && gameOver ==false){
Time.timeScale = 1;
}
}
public void AddScore(int s, RingInfoinfo){
score += s;
HudText hud = ((GameObject)GameObject.Instantiate(Resources.Load(“HudText”))).transform.GetComponent<HudText>();
hud.SetText(“+” + s);
scoreText.text = score.ToString();
levelText.text = info.index.ToString();
}
}
###RingInfo.cs
（D:\zz_DemoPro()-\小案例002、耳轮跳-HelixJump-\Assets\Project\Scripts\RingInfo.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//立钻哥哥：环信息
public class RingInfo:MonoBehaviour{
public int index; //层数
public bool isBreaken=false; //是否击毁
GameObject ball;
private void Start(){
ball = GameObject.Find(“Ball”);
}
private void Update(){
if(ball == null){
return;
}
if(ball.transform.position.y < transform.position.y - 0.1f && !isBreaken){
isBreaken = true;
//提高小球势能
GameObject.Find(“Ball”).GetComponent<BallFallScript>().power += 1;
int power=GameObject.Find(“Ball”).GetComponent<BallFallScript>().power;
//计算分数，与通过的势能相等
GameObject.FindObjectOfType<GameMgr>().AddScore(power*4,this);
Explosion();
}
}
public void Explosion(){
//打散散开
for(int i=0; i <transform.childCount; i++){
if(transform.GetChild(i).gameObject.activeSelf == false){
continue;
}
Rigidbody rig;
if((rig = transform.GetChild(i).gameObject.GetComponent<Rigidbody>()) == null){
rig = transform.GetChild(i).gameObject.AddComponent<Rigidbody>();
}
rig.AddForce((transform.GetChild(i).forward+Vector3.up*Random.Range(0.3f,1)) * Random.Range(40,80));
transform.GetChild(i).GetComponent<MeshCollider>().enabled = false;
}
StartCoroutine(ChangeAlpha()); //渐隐
GameObject.Destroy(gameObject,3); //3s后销毁
}
IEnumerator ChangeAlpha(){
float alpha = 1;
while(true){
alpha -= Time.deltaTime;
for(int i =0; i < transform.childCount; i++){
if(transform.GetChild(i).gameObject.activeSelf == false){
continue;
}
Material mat =transform.GetChild(i).GetComponent<MeshRenderer>.material;
transform.GetChild(i).GetComponent<MeshRenderer>.material.color= new Color(mat.color.r,mat.color.g,mat.color.b,alpha)
}
yield return null;
}
}
}
###RotatePillar.cs
（D:\zz_DemoPro()-\小案例002、耳轮跳-HelixJump-\Assets\Project\Scripts\RotatePillar.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class RotatePillar:MonoBehaviour{
private void Update(){
if(Input.GetMouseButton(0)){
float y =Input.GetAxis(“Mouse X”);
transform.Rotate(Vector3.up, -Time.deltaTime*180*y);
}
}
}
###SectorInfor.cs
（D:\zz_DemoPro()-\小案例002、耳轮跳-HelixJump-\Assets\Project\Scripts\SectorInfo.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class SectorInfo:MonoBehaviour{
public bool IsTrap{ get; set; }
}
#小案例003、MVC框架（提升等级案例）
++小案例003、MVC框架（提升等级案例）
++++PlayerMsgController.cs
++++PlayerMsgView.cs
++++PlayerScript.cs
###PlayerMsgController.cs
（C:\000-ylzServ_DemoPro\小案例003\Assets\PlayerMsgController.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//Controller层：
public class PlayerMsgController : MonoBehaviour{
public static PlayerMsgController controller;
private int levelUpValue=20;
void Awake(){
controller = this;
}
void Start(){
PlayerScript.GetMod().PlayerLevel = 1;
PlayerScript.GetMod().PlayerExperience = 0;
PlayerScript.GetMod().PlayerFullExperience = 100;
PlayerScript.GetMod().GoldNum = 0;
}
//提升经验按钮点击事件
public void OnExperienceUpButtonClick(){
PlayerScript.GetMod().PlayerExperience += levelUpValue;
if(PlayerScript.GetMod().PlayerExperience >= PlayerScript.GetMod().PlayerFullExperience){
PlayerScript.GetMod().PlayerLevel +=1;
PlayerScript.GetMod().PlayerFullExperience += 200*PlayerScript.GetMod().PlayerLevel;
levelUpValue += 20;
if(PlayerScript.GeMod().PlayerLevel % 3 == 0){
PlayerScript.GetMod().GoldNum += 100*PlayerScript.GetMod().PlayerLevel;
}
}
}
}
###PlayerMsgView.cs
（C:\000-ylzServ_DemoPro\小案例003\Assets\PlayerMsgView.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
//立钻哥哥：UI视图层
public class PlayerMsgView :MonoBehaviour{
//UI
public Text playerLevel;
public Text playerExperience;
public Text goldNum;
public Button experienceUpButton;
void Start(){
//委托事件绑定
PlayerScript.GetMod().OnLevelChange += SetLevel;
PlayerScript.GetMod().OnExperienceChange += SetExperience;
PlayerScript.GetMod().OnFullExperienceChange += SetFullExperience;
PlayerScript.GetMod().OnGlodNumChange += SetGoldNum;
//View绑定按钮控制功能
//添加观察者：
experienceUpButton.onClick.AddListener(
PlayerMsgController.controller.OnExperienceUpButtonClick);
}
//修改UILevel值
public void SetLevel(int level){
playerLevel.text = level.ToString();
}
//修改UI经验值
public void SetExperience(int experience){
//将字符串以”/”拆开
string[] str = playerExperience.text.Split(newchar[]{‘/’ });
}
public void SetFullExperience(int fullExperience){
string[] str = playerExperience.text.Split(newchar []{ ‘/’ });
playerExperience.text = str[0] +“/” + fullExperience;
}
public void SetGoldNum(int goldn){
goldNum.text = goldn.ToString();
}
}
###PlayerScript.cs
（C:\000-ylzServ_DemoPro\小案例003\Assets\PlayerScript.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//模型委托（当用户信息发生变化时执行）
public delegate void OnValueChange(int val);
public class PlayerScript{
private int playerLevel; //玩家等级
private int playerExperience; //玩家经验
private int playerFullExperience; //玩家升级经验
private int goldNum; //金币数量
//声明委托对象
public OnValueChange OnLevelChange; //当等级发生变化时，触发的事件
public OnValueChange OnExperienceChange; //当经验发生变化时，触发的事件
public OnValueChange OnFullExperienceChange; //当升级经验发生变化时
public OnValueChange OnGoldNumChange; //当金币数量发生变化时
private static PlayerScript mod; //单例
public static PlayerScript GetMod(){
if(mod == null){
mod = new PlayerScript();
}
return mod;
}
private PlayerScript(){
}
//玩家等级属性
public int PlayerLevel{
get{
return playerLevel;
}
set{
playerLevel = value;
if(OnLevelChange!= null){
//如果委托对象不为空
OnLevelChange(playerLevel); //执行委托
}
}
}
//玩家经验属性
public int PlayerExperience{
get{
return playerExperience;
}
set{
playerExperience = value;
if(OnExperienceChange !=null){
OnExperienceChange(playerExperience);
}
}
}
//玩家升级经验属性
public int PlayerFullExperience{
get{
return playerFullExperience;
}
set{
playerFullExperience = value;
if(OnFullExperienceChange!= null){
OnFullExperienceChange(playerFullExperience);
}
}
}
//金币数量属性
public int GoldNum{
get{
return goldNum;
}
set{
goldNum = value;
if(OnGoldNumChange != null){
OnGoldNumChange(goldNum);
}
}
}
}
#小案例004、简单背包案例
++小案例004、简单背包案例
++++Controller/
--PlayerBagController.cs
++++Model/
--PlayerModelScript.cs
--ToolModel.cs
++++View/
--BagView.cs
--GridView.cs
--HPView.cs
--PlayerBagView.cs
--PlayerInfoView.cs
##Controller/
++Controller/
++++PlayerBagController.cs
###PlayerBagController.cs
（C:\000-ylzServ_DemoPro\小案例004\Bag\Assets\Scripts\Controller\PlayerBagController.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using System;
using System.Reflection;
using UnityEditor;
//实现赋值数据，展示数据，物品拖拽，交换等主要功能
// 赋值M -- V交互
public class PlayerBagController :MonoBehaviour,IMoveHandle{
//引入背包视图，相当于将其下的所有子物体脚本都引入
public BagView bagView; //背包视图
void Start(){
MakeData(); //赋值数据
ShowData(); //展示数据
}
//测试数据：
PlayerModelScriptplayer;
public Sprite s1;
public Sprite s2;
public Sprite s3;
public Sprite s4;
//public Sprite s5;
//public Sprite s6;
void MakeData(){
player = new PlayerModelScript(“立钻哥哥”,1000,200);
ToolModel t1 = new ToolModel(“道具1”,ToolType.HP,2000,s1);
ToolModel t2 = new ToolModel(“道具2”,ToolType.HP,500,s2);
ToolModel t3 = new ToolModel(“道具3”,ToolType.ATK,300,s3);
ToolModel t4= new ToolModel(“道具4”,ToolType.ATK,100,s4);
//放入指定下标
player.bagArray[0] = t1;
player.bagArray[5] = t2;
player.bagArray[16] = t3;
player.bagArray[7] =t4;
}
void ShowData(){
//背包
//生成背包格子
creatGrid(
player.bagArray,
bagView.playerBagView.gridGroupView.transform,
“BagGrid”);
//装备
creatGrid(){
player.gearArray,
bagView.playerInfoView.gridGroupView.transform,
“GearGrid”
};
//显示生命值
bagView.playerInfoView.hpView.HPValue.text=player.HP.ToString();
}
//1、根据数组元素个数生成
//2、父物体
//3、格子tag值
void creatGrid(ToolModel[] arr, Transform t, string gridTag){
for(int i=0; i <arr.Length; i++){
//生成格子
GameObject obj = Instantiate<GameObject>(
Resources.Load<GameObject>(“Perfabs/GridView”),
Vector3.zero,
Quaternion.identity
);
//参数赋值：
obj.tag = gridTag; //tag值：格子tag赋值给生成的格子
GridView gv = obj.GetComponent<GridView>(); //获取脚本组件
gv.index =i; //设置格子index
//走过之一段代码之后controller就为格子的代理，那么其就要执行接口里边的方法
gv.moveHandle = this; //设置代理
//给图片赋值
if(arr[i] != null){
gv.contentImage.gameObject.SetActive(true); //**image
gv.contentImage.sprite = arr[i].toolSprite;
}
//添加到父物体
obj.transform.SetParent(t);
}
}
/*
移动有四种情况：
--1、背包--->背包
--2、背包--->装备
--3、装备--->装备
--4、装备--->背包
--5、有--->无
--6、丹药类型点击消失增加属性
*/
//实现接口方法
Transform targetTransform; //目标位置
public void BeginMove(GridView grid, PointerEventData pointData){
if(grid.tag == “BagGrid”){
//判空：如果背包数组没有东西那么不需要移动
if(player.bagArray[grid.index] == null){
return;
}
}
if(gird.tag == “GearGrid”){
//判空：装备格子判断
if(player.gearArray[gird.index] == null){
return;
}
}
#warning有数据
//有数据：开始拖拽前记录信息不交换时候让其回到原来位置
targetTransform = grid.contentImage.transform;
gird.contentImage.raycastTarget = false; //关闭射线检测（检测后方物体）
targetTransform.SetParent(targetTransform.root); //脱离父物体
}
public void Move(GridView grid, PointerEventData pointData){
if(targetTransform == null){
//如果目标为空，那么返回原来位置
return;
}
targetTransform.position = Input.mousePosition;
}
//PointerEventData：系统方法
public void EndMove(GridView grid, PointerEventData pointData){
if(targetTransform==null){
return;
}
//pointData.pointerEnter：目标物体
GameObject pointerEnter = pointData.pointerEnter; //鼠标松手后最后触碰的物体
//从背包区开始拖拽
if(grid.tag == “BagGrid”){
//到背包区
if(pointerEnter.tag == “BagGrid”){
GridView gv = pointerEnter.GetComponent<GridView>();
//判断格子中是否有物品
//gv：目标格子
if(player.bagArray[gv.index] == null){
ChangeUINullGrid(grid, gv); //grid：当前格子
}else{
ChangeUIFullGrid(grid, gv); //变UI
}
//变数据
ToolModel tm = player.bagArray[gv.index];
player.bagArray[gv.index] = player.bagArray[gird.index];
player.bagArray[grid.index] = tm;
}
//到装备区
if(pointerEnter.tag == “GearGrid”){
//判断拖拽的是否是装备
if(player.bagArray[gird.index].type == ToolType.ATK){
GridView gv = pointerEnter.GetComponent<GridView>();//获取脚本组件
//判断是否有数据
if(player.gearArray[gv.index] == null){
ChangeUINullGrid(gird,gv); //无
}else{
ChangeUIFullGrid(grid,gv); //有
}
//数据交换
ToolModel tm = player.bagArray[gird.index];
player.bagArray[gird.index] = player.gearArray[gv.index];
player.gearArray[gv.index] = tm;
}
}
}
//从装备区拖拽
if(grid.tag == “GearGrid”){
//到装备区
if(pointerEnter.tag == “GearGrid”){
GridView gv = pointerEnter.GetComponent<GridView>();
if(player.gearArray[gv.index] == null){
ChangeUINullGrid(grid,gv); //空
}else{
ChangeUIFullGrid(grid,gv); //不空
}
//交换数据
ToolModel tm = player.gearArray[gv.index];
player.gearArray[gv.index] = player.gearArray[grid.index];
player.gearArray[grid.index] = tm;
}
//到背包
if(pointerEnter.tag == “BagGrid”){
GridView gv = pointerEnter.GetComponent<GridView>();
bool isChange =true; //判断是否交换
if(player.bagArray[gv.index] == null){
ChangeUINullGrid(gird,gv); //空
}else{
//判断物体的类型
//如果不是装备则UI不交换
if(player.bagArray[gv.index].type == ToolType.ATK){
ChangeUIFullGrid(grid,gv); //不空
}else{
isChange =false;
}
}
if(isChange){
//数据
ToolModel tm = player.bagArray[gv.index];
player.bagArray[gv.index] = player.gearArray[grid.index];
player.gearArray[grid.index] = tm;
}
}
}
targetTransform.SetParent(grid.transform); //返回原来的格子
targetTransform.localPosition = Vector3.zero; //在父物体的位置localPosition归0
targetTransform = null; //清0
}
public void ClickTool(GridView grid, PointerEventData pointData){
if(player.bagArray[grid.index] != null){
if(player.bagArray[grid.index].type == ToolType.HP){
//数据更新
player.HP+= player.bagArray[grid.index].value;
player.bagArray[grid.index] = null;
//UI更新
bagView.playerInfoView.hpView.HPValue.text = player.HP.ToString();
grid.contentImage.sprite = null;
grid.contentImage.gameObject.SetActive(false);
}
}
}
#region 改变UI
//放到没有物品的格子中（destination： 目标格子）
void ChangeUINullGrid(GridView origin, GridView destination){
destination.contentImage.gameObject.SetActive(true); //目的格子图片**
//将源格子的图片赋值给目的格子
destination.contentImage.sprite = origin.contentImage.sprite;
origin.contentImage.sprite = null; //将源格子图片清空
origin.contentImage.gameObject.SetActive(false); //将源格子图片取消**
}
//放到有物品的格子中
void ChangeUIFullGrid(GridView origin, GridView destination){
Sprite s = destination.contentImage.sprite;
destination.contentImage.sprite = origin.contentImage.sprite;
origin.contentImage.sprite = s;
}
#endregion
}
##Model/
++Model/
++++PlayerModelScript.cs
++++ToolModel.cs
###PlayerModelScript.cs
（C:\000-ylzServ_DemoPro\小案例004\Bag\Assets\Scripts\Model\PlayerModelScript.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerModelScript{
public string playerName{get;set; } //姓名
public int HP{get;set; } //血量
public int ATK{get;set; } //攻击力
public ToolModel[] gearArray; //装备区
public ToolModel[] bagArray; //背包
public PlayerModelScript(string name,int hp,int atk){
playerName = name;
HP = hp;
ATK = atk;
gearArray = new ToolModel[8]; //装备
bagArray = new ToolModel[20]; //背包
}
}
###ToolModel.cs
（C:\000-ylzServ_DemoPro\小案例004\Bag\Assets\Scripts\Model\ToolModel.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public enmu ToolType{
HP,
ATK
}
//立钻哥哥：道具Model类
public class ToolModel{
public string toolName{set;get; } //道具名字
public ToolType type{set;get; } //道具类别
public int value{set;get; } //数值
public Sprite toolSprite{set;get; } //道具图片
//构造方法
public ToolModel(string name, ToolTypett, int v, Sprite sp){
toolName = name;
type = tt;
value = v;
toolSprite = sp;
}
}
##View/
++View/
++++BagView.cs
++++GridView.cs
++++HPView.cs
++++PlayerBagView.cs
++++PlayerInfoView.cs
###BagView.cs
（C:\000-ylzServ_DemoPro\小案例004\Bag\Assets\Scripts\View\BagView.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//挂载在BagView上，目的收集子视图View
public class BagView :MonoBehaviour{
public PlayerInfoView playerInfoView; //人物界面
public PlayerBagView playerBagView; //背包界面
}
###GridView.cs
（C:\000-ylzServ_DemoPro\小案例004\Bag\Assets\Scripts\View\GridView.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
//using System.Net.NetworkInformation;
//移动的接口
public interface IMoveHandle{
void BeginMove(GridView grid, PointerEventData pointData); //鼠标进入
void Move(GridView grid, PointerEventData pointData); //移动
void EndMove(GridView grid, PointerEventData pointData); //结束移动
void ClickTool(GridView grid, PointerEventData pointData); //点击的道具
}
public class GridView : MonoBehaviour,IBeginDragHandler,IDragHandler,IEndDragHandler,IPointerClickHandler{
public Image contentImage;
public int index{set;get; } //格子创建时的下标，标记它的目的是为了在交换物品或者移动时候和数组元素对应
public IMoveHandle moveHandle; //将接口定义为视图的字段或者属性
//实现继承过来接口里边的内容
public void OnBeginDrag(PointerEventData eventData){
moveHandle.BeginMove(this,eventData);
}
public void OnDrag(PointerEventData eventData){
moveHandle.Move(this,eventData);
}
public void OnEndDrag(PointerEventData eventData){
moveHandle.EndMove(this,eventData);
}
public void OnPointerClick(PointerEventData eventData){
moveHandle.ClickTool(this,eventData);
}
}
###HPView.cs
（C:\000-ylzServ_DemoPro\小案例004\Bag\Assets\Scripts\View\HPView.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
//获得它下边的两个文本
public class HPView : MonoBehaviour{
public Text HpText;
public Text HPValue;
}
###PlayerBagView.cs
（C:\000-ylzServ_DemoPro\小案例004\Bag\Assets\Scripts\View\PlayerBagView.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerBagView: MonoBehaviour{
public RectTransform gridGroupView;
}
###PlayerInfoView.cs
（C:\000-ylzServ_DemoPro\小案例004\Bag\Assets\Scripts\View\PlayerInfoView.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//任务属性界面脚本（目的：收集其子物体关于View的脚本）
public class PlayerInfoView : MonoBehaviour{
public RectTransform gridGroupView; //格子视图
public HPView hpView;
}
#小案例005、塔防Demo
++小案例005、塔防Demo
++++BulletScript.cs
++++CameraMoveScript.cs
++++EndScript.cs
++++GameDataScript.cs
++++InitMonsterScript.cs
++++InitTowerScript.cs
++++MonsterScript.cs
++++TowerFireScript.cs
###BulletScript.cs
（D:\000-ylzServ_DemoPro\小案例005\Assets\DemoBak\Homework\BulletScript.cs）
using UnityEngine;
using System.Collections;
//该脚本功能是控制子弹的发射和碰撞检测（加到粒子特效上，模拟子弹）
public class BulletScript :MonoBehaviour{
public Transform target; //子弹要攻击的目标
public float bulletSpeed=3; //子弹的飞行速度
public float damager=100; //子弹的伤害值
void Update(){
if(target){
Vector3 dir =target.position-transform.position; //得到子弹要飞行的向量
Transform.position += dir*Time.deltaTime*bulletSpeed; //子弹移动
}else{
Destroy(gameObject); //如果目标是空，把子弹销毁
}
}
void OnTriggerEnter(Collider other){
if(other.tag == “monster”){
Other.GetComponent<MonsterScript>().health -= damage; //怪物掉血
Destroy(this.gameObject); //把子弹销毁掉
}
}
}
###CameraMoveScript.cs
（D:\000-ylzServ_DemoPro\小案例005\Assets\DemoBak\Homework\CameraMoveScript.cs）
using UnityEngine;
using System.Collections;
public class CameraMoveScript : MonoBehaviour{
public float moveSpeed =3;
void Update(){
float hor = Input.GetAxis(“Horizontal”);
float ver = Input.GetAxis(“Vertical”);
transform.position += new Vector3(hor,0,ver) *Time.deltaTime*moveSpeed;
}
}
###EndScript.cs
（D:\000-ylzServ_DemoPro\小案例005\Assets\DemoBak\Homework\EndScript.cs）
using UnityEngine;
using System.Collections;
//加在End物体上，功能是当怪物触发后，把怪物销毁
public class EndScript : MonoBehaviour{
void OnTriggerEnter(Collider other){
if(other.tag == “monster”){
Debug.Log(“tttt”);
Destroy(other.gameObject);
}
}
}
###GameDataScript.cs
（D:\000-ylzServ_DemoPro\小案例005\Assets\DemoBak\Homework\GameDataScript.cs）
using UnityEngine;
using System.Collections;
using System;
//功能是控制所生成怪物的数量，速度和时间间隔，主要的思路是用一个结构体数组，数组的长度即为波数，每一波对应数组里面的一个元素，读取结构体里面的数据。
public class GameDataScript : MonoBehaviour{
public static GameDataScript Instance;
public struct Data{
public float waitTime; //等待多长时间产生一波敌人
public int monsterCount; //每一波敌人的数量
public float moveSpeed; //每一波敌人的移动速度
}
//刚开始时的默认数据
float waitTimeDefault =3;
int monsterCountDefault= 3;
float moveSpeedDefault =2;
public Data[] monsterData; //每一波所对应的数据
void Awake(){
Instance = this;
}
void Start(){
monsterData = new Data[10];
for(int i =0; i < monsterData.Length; i++){
//第一次循环时把默认数据赋值给第一个元素
monsterData[i].waitTime =waitTimeDefault;
monsterData[i].monsterCount = monsterCountDefault;
monsterData[i].moveSpeed =moveSpeedDefault;
//每循环一次数据增加
waitTimeDefault += 0.5f;
monsterCountDefault += 1;
moveSpeedDefault += 0.3f;
}
}
}
###InitMonsterScript.cs
（D:\000-ylzServ_DemoPro\小案例005\Assets\DemoBak\Homework\InitMonsterScript.cs）
using UnityEngine;
using System.Collections;
//怪物生成（加到Start空物体上）
public class InitMonsterScript : MonoBehaviour{
puiblic GameObject monster; //怪物预设体
float timer; //计时器
int index = 0; //生成怪物的波数
bool isInit = false //当前是否正在生成怪物
int monsterCount = 0; //一波中怪物的数量
bool isGaming=true; //是否在游戏中
void Update(){
if(isGaming){
timer += Time.deltaTime;
//读取Data数组中index中相对应的元素，再找到里面对应的相关数据
//1、先得到时间间隔
float timeInterval = GameDataScript.Instance.monsterData[index].waitTime;
//2、如果计时器达到等待生成怪物的时间，并且没有初始化怪物，则把计时器归0，开始初始化怪物
if(!isInit && timer > timeInterval){
timer = 0;
isInit =true;
}else if(isInit){
//如果能初始化怪物
if(timer > 1){
//每隔一秒生成一个怪物
timer =0;
GameObject currentMonster = Instantiate(monster,transform.position,Quaternion.identity) as GameObject; //生成怪物
currentMonster.GetComponent<UnityEngine.AI.NavMeshAgent>().speed = GameDataScript.Instance.monsterData[index].moveSpeed; //把数据组中的速度赋值给导航中的速度
monsterCount++; //怪物数量增加
if(monsterCount == GameDataScript.Instance.monsterData[index].monsterCount){
//如果怪物生成的数量与给定的数量相同
monsterCount = 0; //数据归零
index++; //进入下一波
isInit = false; //不能再进行初始化了
if(index >GameDataScript.Instance.monsterData.Length-1){
//说明波次已经够了，此时游戏结束
isGaming =false;
}
}
}
}
}
}
}
###InitTowerScript.cs
（D:\000-ylzServ_DemoPro\小案例005\Assets\DemoBak\Homework\InitTowerScript.cs）
using UnityEngine;
using System.Collections;
//加到空GameController上，主要的功能是点击鼠标左键，创建炮塔
public class InitTowerScript :MonoBehaviour{
public GameObject tower;
RaycastHit hit;
void Update(){
//如果按下鼠标左键
if(Input.GetMouseButtonDown(0)){
//从摄像机到鼠标点击位置发出一条射线
if(Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit)){
Debug.Log(hit.collider.name);
//检测点击到的是否是木箱，如果名字中包含Tower，并且没有子物体
if(hit.collider.name.IndexOf(“Tower”) != -1 && hit.collider.transform.childCount ==0){
Vector3 pos =hit.collider.transform.position+Vector3.up* 2.65f;
GameObject gun = Instantiate(tower,pos,Quaternion.identity) as GameObject; //生成大炮
gun.transform.SetParent(hit.collider.transform); //给生成的炮塔设置父物体
}
}
}
}
}
###MonsterScript.cs
（D:\000-ylzServ_DemoPro\小案例005\Assets\DemoBak\Homework\MonsterScript.cs）
using UnityEngine;
using System.Collections;
//功能是控制怪物的运动（脚本加到Monster上）
public class MonsterScript :MonoBehaviour{
public float health = 100; //生命值
UnityEngine.AI.NavMeshAgent nav; //导航组件
Transform end; //终点
Animation ani; //动画组件
void Awake(){
nav = GetComponent<UnityEngine.AI.NavMeshAgent>();
ani = GetComponent<Animation>();
end = GameObject.FindWithTag(“end”).transform;
}
void Start(){
nav.destination = end.position;
}
void Update(){
//如果血量小于等于0
if(health <0){
GetComponent<CapsuleCollider>().enabled = false; //关闭碰撞器
ani.CrossFade(“Dead”);
Destroy(gameObject,1); //1秒钟后销毁自己
}
}
}
###TowerFireScript.cs
（D:\000-ylzServ_DemoPro\小案例005\Assets\DemoBak\Homework\TowerFireScript.cs）
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class TowerFireScript :MonoBehaviour{
public GameObject bullet; //生成炮弹
public float fireRadius= 7f; //攻击半径
public float rotateSpeed=3f; //炮头转向速度
public float distance=0.5f; //炮头与炮身之间的距离
public float bullectMoveSpeed=5f; //子弹飞行的速度
public Transform fireTarget; //攻击的目标
public float fireTimeInterval=0.5f; //发射子弹的间隔时间
private float timer=0; //计时器
private Queue<Transform> monsterQueue; //怪物的队列
void Awake(){
monsterQueue = new Queue<Transform>();
}
void Start(){
}
void Update(){
//如果攻击目标为空
if(fireTarget == null){
if(monsterQueue.Count>0){
fireTaget = monsterQueue.Dequeue();
}
}else{
Fire();
}
}
//当怪物进入触发器中，把该怪物添加到要攻击的队列中
void OnTriggerEnter(Collider other){
Debug.Log(“enter”);
//如果是怪物
if(other.tag == “monster”){
monsterQueue.Enqueue(other.transform);
}
}
//离开触发
void OnTriggerExit(Collider other){
Debug.Log(“exit”);
if(other.tag == “monster”){
//如果是当前正在攻击的目标
if(other.transform == fireTarget){
fireTarget= null; //把攻击目标设置为空
}else{
//如果队列不为空
if(monsterQueue.Count>0){
monsterQueue.Dequeue();
}
}
}
}
void Fire(){
Vector3 dir =fireTarget.position-transform.position;
Quaternion rotation = Quaternion.LookRotation(dir);
transform.rotation =Quaternion.Lerp(transform.rotation,rotation,Time.deltaTime*rotateSpeed);
Debug.DrawRay(transform.position, dir,Color.red);
Debug.DrawRay(transform.position, transform.forward * 10,Color.green);
if(Vector3.Angle(dir,transform.forward) <5){
InitBullet();
}
}
void InitBullet(){
timer += Time.deltaTime;
if(timer >fireTimeInterval){
timer = 0;
Vector3 point = transform.GetChild(0).position+transform.GetChild(0).forward*distance;
GameObject currentBullet =Instantiate(bullet,point,Quaternion.identity)asGameObject;
currentBullet.GetComponent<BulletScript>().target = this.fireTarget;
currentBullet.GetComponent<BulletScript>().bulletSpeed = this.bulletMoveSpeed;
}
}
}
#小案例006、秘密行动Demo（NG进行中）
++小案例006、 秘密行动Demo
++++AlarmLight.cs
++++CameraMovement.cs
++++CCTVPlayerDetection.cs
++++DoorAnimation.cs
++++EnemyAI.cs
++++EnemyAnimation.cs
++++EnemyShooting.cs
++++EnemySight.cs
++++HashIDs.cs
++++KeyPickup.cs
++++LaserController.cs
++++LaserSwitchDeactivation.cs
++++LastPlayerSighting.cs
++++LiftDoorsTracking.cs
++++PlayerHealth.cs
++++PlayerInventory.cs
++++PlayerMovement.cs
++++SyncDoor.cs
++++Tags.cs
++秘密行动思维导图
---0、添加Tag脚本
---1、添加场景模型
---2、创建一个空游戏物体
---3、添加英雄char_ethan
---4、添加平行光
---5、给主摄像机添加脚本，用来控制摄像机的移动
---6、在GameController上添加子物体SecondSound
---7、给警报喇叭添加标签
---8、给GameController添加脚本LastPlayerSighting
---9、添加激光灯
---10、创建空物体Doors，用来管理自动门
---11、创建空物体SwitchUnits来控制激光门的开和关
---12、添加钥匙卡
---13、添加CCTV摄像机
---14、添加电梯外面的开关门
---15、添加电梯
---16、放置巡逻点
---17、小机器人
---18、添加手枪
---======================---===============---
++++0、添加Tag脚本，该脚本可以直接取到tag值，不加到任何游戏物体上。
++++1、添加场景模型
--1.1、添加 env_stealth_static
--1.2、添加卡车 prop_battleBus
--1.3、添加网格碰撞器 env_stealth_collision
++++2、创建一个空游戏物体
--2.1、命名GameController
--2.2、添加声音组件播放背景音乐
---playonawake = true,
---loop = true,
---volume = 1
--2.3、添加脚本HashID，用来给动画控制设置参数。
--2.4、添加tag值GameController
++++3、添加英雄 char_ethan
--3.1、添加胶囊碰撞器
--3.2、添加刚体，冻结所有的旋转以及y轴方向的位置
--3.3、添加声音组件，声音片段为脚步声
--3.4、添加动画控制器PlayerAnimator
--3.5、添加脚本PlayerHealth，用来控制英雄的少血以及死亡
--3.6、添加脚本PlayerMove，用来控制英雄的移动
--3.7、添加tag值Player
++++4、添加平行光
--4.1、做了警报灯，颜色为红色，intensity=0
--4.2、添加脚本AlarmLight脚本组件，用来控制警报灯由明变暗再由暗变明
--4.3、添加tag值AlarmLight
++++5、给主摄像机添加脚本，用来控制摄像机的移动
--5.1、Editor/ProjectSetting/Physic/Hit Triggers取消勾选（否则射线会检测触发器，取消后只会检测碰撞器）
--5.2、添加脚本CameraMove
++++6、在GameController上添加子物体SecondSound
--6.1、给子物体添加AudioSource组件
--6.2、添加声音片段music_panic
--6.3、设置声音的初始值为0
--6.4、PlayOnAwake和Loop勾选
++++7、给警报喇叭添加标签
--7.1、给prop_megaphon添加siren标签
--7.2、给六个喇叭添加AudioSource组件
--7.3、添加声音片段alarm_trigger
--7.4、设置声音的初始值为0
--7.5、PlayOnAwake和Loop勾选
++++8、给GameController添加脚本LastPlayerSighting
++++9、添加激光灯
--9.1、创建空物体Lasers用来管理激光门
--9.2、把fx_laserFence_lasers插到场景中并放到合适的位置（大小和旋转）
--9.3、添加AudioSource组件，加上laser_hum声音片段，把Loop和PlayOnAwake勾选，音量设置为1
--9.4、添加点灯源组件，颜色为红色，Range=5，Intensity=1.5，Bounce=1
--9.5、添加一个Box触发器，用来进行触发检测
--9.6、添加脚本LaserController
++++10、创建空物体Doors，用来管理自动门
--10.1、把door_generic_slide拖到合适的位置
--10.2、添加球形触发器，半径为1.5，高为1。
在门的子物体上添加盒形碰撞器，防止没有钥匙的时候，玩家可以直接穿透门
--10.3、添加AudioSource组件，和door_open声音片段，最小距离1，最大距离为5
--10.4、添加DoorAnimator动画控制器组件，给自动门添加动画，添加播放声音的事件
--10.5、添加脚本DoorAnimation
++++11、创建空物体SwitchUnits来控制激光门的开和关
--11.1、拖动prop_switchUnit_screen到场景中
--11.2、在父物体上添加Box碰撞器，在子物体上添加Box触发器，在子物体上添加声音组件
--11.3、添加脚本 LaserSwitchDeactivation
++++12、添加钥匙卡
--12.1、拖动prop_keycard到场景中合适的位置
--12.2、添加球形触发器
--12.3、添加点光源，颜色为蓝色
--12.4、添加动画控制器组件
++++13、添加CCTV摄像机
--13.1、Y轴旋转180度
--13.2、子物体_body x轴旋转30度
--13.3、给子物体_joint添加帧动画
--13.4、在_body子物体下添加空物体trigger，沿X轴旋转30度，并添加MeshCollider组件，添加prop_cctvCam_collision，并使其变为触发器
--13.5、添加Light组件，选择spot的灯光，Range=40, Angle=62，intensity=4, bounce=1, cookie选择fx_cameraView_alp
--13.6、给trigger子物体添加脚本CCTV
++++14、添加电梯外面的开关门
--14.1、拖动door_exit_outer到合适的位置，沿y轴旋转-90
--14.2、添加球形碰撞器
--14.3、添加声源组件，添加open_door声音片段
--14.4、添加动画控制器RedDoorAnimator
--14.5、添加DoorAnimation脚本组件
++++15、添加电梯
--15.1、拖动prop_lift_exit到电梯井里面，并沿Y轴旋转-90
--15.2、添加声源组件，并添加endgame声音片段
--15.3、给子物体_carriage添加声源组件，添加lift_rise声音片段
--15.4、给_carriage添加四个box碰撞器：
---第一个设置为trigger，
---第二个center.z=2（其余不变）, size.z=0.15（其余不变）
---第三个center.z=2（其余不变），size.z=0.15（其余不变）
---第四个center.x=1.87，其余为0，size.x=0.2
--15.5、给carriage添加脚本LiftDoor
--15.6、给子物体door_inner添加脚本SyncDoor
++++16、放置巡逻点
++++17、小机器人
--17.1、添加小机器人的动画控制器EnemyAnimatorController
--17.2、在hashids里面添加新的动画参数值
--17.3、添加动画遮罩EnemyShootingMask
--17.4、设置射击层的过渡条件
--17.5、设置导航路面
--17.6、给小机器人添加animator组件，刚体组件，胶囊体碰撞器，球形触发器导航组件
--17.7、添加EnemySight组件
++++18、添加手枪
--18.1、在机器人char_robotGuard_RightHandThumb1下添加子物体prop_sciFiGun_low
--18.2、在枪的子物体下添加子物体Effect，添加灯光组件以及linerander组件，二者都设置为不可用。
--18.3、给射击的动画片段添加动画曲线
--18.4、添加脚本EnemyAnimation
--18.5、在场景中添加小机器人巡逻的小旗帜
--18.6、添加脚本EnemyAI
--18.7、添加脚本EnemyShooting
###AlarmLight.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\AlarmLight.cs）
using UnityEngine;
using System.Collections;
public class AlarmLight:MonoBehaviour{
public bool alarmOn=false; //是否开启警报
public float turnSpeed=3f; //警报灯切换速度
private float highIntensity=2f; //高光强
private float lowIntensity=0f; //低光强
private float targetIntensity=0f; //目标光强
private Light alarmLight; //警报灯光
void Awake(){
alarmLight = GetComponent<Light>(); //获取警报灯
targetIntensity = highIntensity; //设置目标光强初始值为高光强
}
void Update(){
//如果警报开启
if(alarmOn){
//警报灯切换到目标光强
alarmLight.intensity = Mathf.Lerp(alarmLight.intensity,targetIntensity,Time.deltaTime*turnSpeed);
//如果当前光强强度到达了目标光强，需要切换目标
if(Math.Abs(targetIntensity-alarmLight.intensity) <0.05f){
//如果当前目标是高光强
if(targetIntensity == highIntensity){
targetIntensity = lowIntensity; //切换目标为低光强
}else{
targetIntensity =highIntensity; //否则切换目标为高光强
}
}
}else{
//警报灯渐变到低光强
alarmLight.intensity = Mathf.Lerp(alarmLight.intensity,lowIntensity,Time.deltaTime*turnSpeed);
//如果已经到达了低光强
if(alarmLight.intensity < 0.05f){
//直接切换光强为0，减少CPU的计算
alarmLight.intensity =lowIntensity;
}
}
}
}
###CameraMovement.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\CameraMovement.cs）
using UnityEngine;
using System.Collections;
public class CameraMovement:MonoBehaviour{
public float moveSpeed= 3f; //摄像机移动速度
public float turnSpeed=10f; //摄像机旋转速度
private Transform player; //玩家
private Vector3 direction; //摄像机与玩家之间的方向向量
private RaycastHit hit; //射线碰撞检测器
private float distance; //摄像机与玩家的最小距离
private Vector3[] currentPoints; //当前所有的点
void Awake(){
player = GameObject.FindWithTag(Tags.Player).transform;
currentPoints = new Vector3[5];
}
void Start(){
//计算玩家头顶方向与摄像机的距离
distance = Vector3.Distance(transform.position,player.position) -0.5f;
//游戏开始时玩家与摄像机之间的方向向量
direction = player.position-transform.position;
}
void Lateupdate(){
Vector3 startPoint =player.position-direction; //第一个点
Vector3 endPoint =player.position+Vector3.up*distance; //最后一个点
currentPoint[1] = Vector3.Lerp(startPoint,endPoint,0.25f); //第二个点
currentPoint[2] = Vector3.Lerp(startPoint,endPoint,0.5f); //第三个点
currentPoint[3] = Vector3.Lerp(startPoint,endPoint,0.75f); //第四个点
//放到数组中
currentPoints[0] = startPoint;
currentPoints[4] = endPoint;
//创建一个点，用来存储选择好可以看到玩家的点
Vector3 viewPosition =currentPoints[0];
//遍历五点
for(int i = 0; i <5; i++){
if(CheckView(currentPoints[i])){
viewPosition = currentPoints[i]; //更新合适的点
break;
}
}
//摄像机移动到指定点
transform.position = Vector3.Lerp(transform.position,viewPosition,Time.deltaTime*moveSpeed);
SmoothRotate(); //执行平滑旋转
}
//检测是否可以看到玩家
//return true:看到了，false:没看到
//param pos:射线发射点
bool checkView(Vector3 pos){
Vector3 dir = player.position -pos; //计算方向向量
//发射射线
if(Physics.Raycast(pos,dir, out hit)){
//如果看到了
if(hit.collider.tag == Tags.Player){
return true;
}
}
return false;
}
//平滑旋转
void SmoothRotate(){
//计算方向向量
Vector3 dir = player.position + Vector3.up* 0.2f-transform.position;
Quaternion qua =Quaternion.LookRotation(dir); //转换为四元数
//平滑移动
transform.rotation =Quaternion.Lerp(transform.rotation,qua,Time.deltaTime*turnSpeed);
//优化Y轴和Z轴旋转
transform.eulerAngles = new Vector3(transform.eulerAngles.x,0, 0);
}
}
###CCTVPlayerDetection.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\CCTVPlayerDetection.cs）
using UnityEngine;
using System.Collections;
public class CCTVPlayerDetection:MonoBehaviour{
private LastPlayerSighting lastPlayerSighting; //传输警报位置
void Awake(){
lastPlayerSighting = GameObject.FindWithTag(Tags.GameController).GetComponent<LastPlayerSighting>();
}
void OnTriggerEnter(Collider other){
//如果是玩家，同步警报位置
if(other.tag == Tags.Player){
lastPlayerSighting.alarmPositon =other.transform.position;
}
}
}
###DoorAnimation.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\DoorAnimation.cs）
using UnityEngine;
using System.Collections;
public class DoorAnimation:MonoBehaviour{
public bool needKey = false; //当前门是否需要钥匙
public AudioClip refuseAud; //拒绝开门的声音片段
private bool playerIn=false; //玩家进入到了大门触发器范围内
private int count=0; //人数
private Animator ani;
private AudioSource aud;
private PlayerInventory playerInventory; //玩家是否拥有钥匙的脚本
void Awake(){
ani = GetComponent<Animator>();
aud = GetComponent<AudioSource>();
playerInventory = GameObject.FindWithTag(Tags.Player).GetComponent<PlayerInventory>();
}
void OnTriggerEnter(Collider other){
//如果进来的是玩家或机器人
if(other.tag ==Tags.Player|| (other.tag ==Tags.Enemy&&other.GetType() ==typeof(CapsuleCollider))){
count++; //人数递增
//如果是玩家
if(other.tag == Tags.Player){
playerIn =true; //设置玩家进入的标志位
//如果玩家没有钥匙
if(!playerInventory.hasKey&&needkey){
//播放拒绝声音
AudioSource.PlayClipAtPoint(refuseAud,transform.position);
}
}
}
}
void OnTriggerExit(Collider other){
//如果进来的是玩家或机器人
if(other.tag == Tags.Player|| (other.tag ==Tags.Enemy&&other.GetType() == typeof(CapsuleCollider))){
count--; //人数递减
//如果是玩家
if(other.tag ==Tags.Player){
playerIn =false; //设置玩家进入的标志位
}
}
}
void Update(){
//不需要钥匙的时候
if(!needKey){
if(count > 0){
ani.SetBool(HashIDs.DoorOpen,true); //门打开
}else{
ani.SetBool(HashIDs.DoorOpen, false); //门关闭
}
}else{
//玩家带着钥匙进去
if(playerIn&&playerInventory.hasKey){
ani.SetBool(HashIDs.DoorOpen, true);
}else{
ani.SetBool(HashIDs.DoorOpen, false);
}
}
}
//动画帧事件，播放开关门声音
public void PlayVoice(){
if(Time.time > 0.1f){
aud.Play(); //播放声音
}
}
}
###EnemyAI.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\EnemyAI.cs）
using UnityEngine;
using System.Collections;
public class EnemyAI:MonoBehaviour{
public Transform[] wayPoints; //巡逻点
public float chasingSpeed=6f; //追捕速度
public float patrallingSpeed= 2.5f; //巡逻速度
public float chasingWaitTime=3f; //巡视时间
private float chasingTimer; //追捕等待计时器
private float patrallingTimer; //巡逻等待计时器
private EnemySight enemySight;
private LastPlayerSighting lastPlayerSighting;
private UnityEngine.AI.NavmeshAgent nav;
private int index; //巡逻目标索引号
private PlayerHealth playerHealth;
void Awake(){
enemySight = GetComponent<EnemySight>();
lastPlayerSighting = GameObject.FindWithTag(Tags.GameController).GetComponent<LastPlayerSighting>();
nav = GetComponent<UnityEngine.AI.NavMeshAgent>();
playerHealth = GameObject.FindWithTag(Tags.Player).GetComponent<PlayerHealth>();
index = 0;
}
void Update(){
if(enemySight.playerInSight&&playerHealth.health>0){
Shooting(); //射击
}else if(enemySight.personalAlarmPosition!=lastPlayerSighting.normalPosition&&playerHealth.health>0){
Chasing(); //追捕
}else{
Patrolling(); //巡逻
}
}
//射击
void Shooting(){
nav.Stop(); //导航停止
}
//追捕
void Chasing(){
nav.Resume(); //恢复导航
nav.speed = chasingSpeed; //加快速度
nav.SetDestination(enemySight.personalAlarmpositon); //设置导航目标
//到达了警报位置
if(nav.remainingDistance -nav.stoppingDistance<0.5f){
chasingTimer += Time.deltaTime; //追捕等待计时器计时
//达到等待时间
if(chasingTimer > chasingWaitTime){
chasingTimer =0; //重置计时器
//警报解除
lastPlayerSighting.alarmPosition =lastPlayerSighting.normalPosition;
}
}else{
chasingTimer = 0; //重置计时器
}
}
//巡逻
void Patrolling(){
nav.speed = patrallingSpeed; //巡逻速度
nav.SetDestination(wayPoints[index].position); //设置巡逻目标
//达到巡逻点
if(nav.remainingDistance- nav.stoppingDistance< 0.5f){
patrallingTimer += Time.deltaTime; //计时器计时
//计时器完成本次计时
if(patrallingTimer >chasingWaitTime){
//更新下一个巡逻点索引号
//index = ++index % wayPoints.Length;
index++;
index =index%wayPoints.Length;
patrallingTimer = 0; //计时器清零
}
}else{
patrallingTimer = 0; //计时器清零
}
}
}
###EnemyAnimation.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\EnemyAnimation.cs）
using UnityEngine;
using System.Collections;
public class EnemyAnimation:MonoBehaviour{
public float deadZone=4; //死角度数
public float dampSpeedTime= 0.1f; //设置动画参数的延迟时间
public float dampAngularSpeedTime=0.1f;
private UnityEngine.AI.NavMeshAgent nav;
private EnemySight enemySight;
private Transform player;
private Animator ani;
void Awake(){
nav = GetComponent<UnityEngine.AI.NavMeshAgent>();
enemySight = GetComponent<EnemySight>();
player = GameObject.FindWithTag(Tags.Player).transform;
ani = GetComponent<Animator>();
deadZone *= Mathf.Deg2Rad; //死角度数转为弧度
}
void OnAnimatorMove(){
nav.velocity = ani.deltaPosition/Time.deltaTime;
transform.rotation =ani.rootRotation;
}
void Update(){
float speed = 0;
float angularSpeed =0;
//如果看到了玩家
if(enemySight.playerInSight){
speed = 0; //停下来
angularSpeed = FindAngle(); //角速度，按导航转向
//如果角度过小，进入死角
if(Mathf.Abs(angularSpeed) < deadZone){
angularSpeed =0; //停止用动画转身
transform.LookAt(player); //机器人直接看向玩家
}
}else{
//直线速度 =机器人前方的投影向量的模
speed = Vector3.Project(nav.desiredVelocity,transform.forward).magnitude;
angularSpeed = FindAngle(); //角速度，按导航转向
}
//设置动画参数
ani.SetFloat(HashIDs.Speed,speed,dampSpeedTime,Time.deltaTime);
ani.SetFloat(HashIDs.AngularSpeed,angularSpeed,dampAngularSpeedTime,Time.deltaTime);
}
float FindAngle(){
Vector3 dir = nav.desiredVelocity; //期望速度
//机器人前方与期望速度形成的夹角
float angle = Vector3.Angle(dir,transform.forward);
//计算两向量的法向量
Vector3 normal = Vector3.Cross(transform.forward,dir);
//如果期望速度在机器人左方，角度为负
if(normal.y <0){
angle *= -1;
}
//将角度转换为弧度
angle *= Mathf.Deg2Rad;
//如果期望速度为0
if(dir ==Vector3.zero){
angle = 0;
}
return angle;
}
}
###EnemyShooting.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\EnemyShooting.cs）
using UnityEngine;
using System.Collections;
public class EnemyShooting:MonoBehaviour{
public float damage= 10; //一枪伤害
private Animator ani;
private Light shootLight;
private LineRenderer shootLine;
private bool shooting = false;
private Transform player;
private PlayerHealth playerHealth;
void Awake(){
ani = GetComponent<Animator>();
shootLight = GetComponentInChildren<Light>();
shootLine = GetComponentInChildren<LineRenderer>();
player = GameObject.FindWithTag(Tags.Player).transform;
playerHealth = player.GetComponent<PlayerHealth>();
}
void Update(){
//射击开始
if(ani.GetFloat(HashIDs.shot) > 0.5f && !shooting){
Shooting();
}elseif(ani.GetFloat(HashIDs.Shot) < 0.5f){
shooting = false;
shootLight.enabled =false;
shootLine.enabled =false;
}
}
//射击
void Shooting(){
shootLight.enabled = true; //打开闪光
//绘制激光线
shootLine.SetPosition(0, shootLine.transform.parent.position);
shootLine.SetPosition(1, player.position+Vector3.up*1.5f);
shootLine.enabled =true;
shooting = true; //正在射击
playerHealth.TakeDamage(damage); //计算伤害
}
void OnAnimatorIK(int layer){
float weight = ani.GetFloat(HashIDs.AimWeight); //获取曲线中的权重
ani.SetIKPositionWeight(AvatarIKGoal.RightHand,weight); //设置IK权重
//设置IK位置
ani.SetIKPosition(AvatarIKGoal.RightHand,player.position+Vector3.up*1.5f);
}
}
###EnemySight.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\EnemySight.cs）
using UnityEngine;
using System.Collections;
public class EnemySight:MonoBehaviour{
public bool playerInSight= false; //能够看到玩家
public float fieldOfView= 110f; //机器人视野夹角
private float distanceOfView; //机器人视野距离
private SphereCollider sph; //机器人触发器
public Vector3 personalAlarmPosition; //私人警报位置
private Vector3 previousAlarmPosition; //上一帧的公共警报位置
private LastPlayerSighting lastPlayerSighting; //公共警报脚本
private RaycastHit hit; //射线碰撞检测器
private UnityEngine.AI.NavMeshAgent nav; //导航组件
private PlayerHealth playerHealth; //玩家血量脚本
private Animator ani; //动画组件
void Awake(){
lastPlayerSighting = GameObject.FindWithTag(Tags.GameController).GetComponent<LastPlayerSighting>();
//获取触发器
sph = GetComponent<SphereCollider>();
nav = GetComponent<UnityEngine.AI.NavMeshAgent>();
playerHealth = GameObject.FindWithTag(Tags.Player).GetComponent<PlayerHealth>();
ani = GetComponent<Animator>();
}
void Start(){
//私人警报初值为非警报位置
personalAlarmPosition = lastPlayerSighting.normalPosition;
//上一帧的公共警报位置初值也为非警报位置
previousAlarmPosition = lastPlayerSighting.normalPosition;
//获取视野距离
distanceOfView = sph.radius;
}
void Update(){
//公共警报一旦发生变化 --->通知到PersonalAlarmPosition
//PersonalAlarmPosition --/-->不能通知给公共警报
//如果上一帧的公共警报位置，与本帧的公共警报位置不一致
if(previousAlarmPosition != lastPlayerSighting.alarmPosition){
//将最新的公共警报位置通知到私人警报位置
personalAlarmPosition = lastPlayerSighting.alarmPosition;
}
//获取本帧的公共警报位置
previousAlarmPosition =lastPlayerSighting.alarmPosition;
//如果玩家血量正常
if(playerHealth.health > 0){
ani.SetBool(HashIDs.PlayerInSight,playerInSight);
}else{
ani.SetBool(HashIDs.PlayerInSight, false);
}
}
void OnTriggerStay(Collider other){
//如果是玩家
if(other.tag ==Tags.Player){
playerInSight = false; //重置
//玩家与机器人的距离
float distance = Vector3.Distance(other.transform.position, transform.position);
//计算机器人自身前方与方向向量之间的夹角
float angular = Vector3.Angle(dir, transform.forward);
//满足视野范围内核距离范围内
if(distance <distanceOfView &&angular<fieldOfView/2){
if(Physics.Raycast(transform.position+Vector3.up*1.7f, dir,outhit)){
if(hit.collider.tag == Tags.Player){
playerInSight = true; //可以看到玩家
//报警
lastPlayerSighting.alarmPosition = other.transform.position;
}
}
}
//听觉：如果机器人与玩家的导航路径在听觉路径范围内
if(EnemyListening(other.transform.position)){
//如果玩家发出了声音
if(other.GetComponent<AudioSource>().isPlaying){
//赋值私人警报位置
personalAlarmPosition =other.transform.position;
}
}
}
}
//机器人与玩家的导航距离在视觉范围内
bool EnemyListening(Vector3 playerPos){
UnityEngine.AI.NavMeshPath path = new UnityEngine.AI.NavMeshPath();
//如果导航可以到达玩家位置
if(nav.CalculatePath(playerPos, path)){
//用数组获取所有的路径点
Vector3[] points =new Vector3[path.corners.Length+2];
points[0] = transform.position; //起点
points[points.Length-1] = playerPos; //终点
//赋值中间的拐点
for(inti =1; i < points.Length-1; i++){
points[i] = path.corners[i -1];
}
float navDistance= 0; //导航距离
//遍历计算距离
for(int i =0; i < points.Length-1; i++){
navDistance +=Vector3.Distance(points[i],points[i +1]);
}
//导航距离在听觉距离范围内
if(navDistance < distanceOfView){
return true;
}
}
return false;
}
}
###HashIDs.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\HashIDs.cs）
using UnityEngine;
using System.Collections;
public class HashIDs :MonoBehaviour{
public static int DoorOpen;
public static int Speed;
public static int Sneak;
public static int AngularSpeed;
public static int Dead;
public static int PlayerInSight;
public static int Shot;
public static int AimWeight;
public static int LocomotionState;
void Awake(){
DoorOpen = Animator.StringToHash(“DoorOpen”);
Speed = Animator.StringToHash(“Speed”);
Sneak = Animator.StringToHash(“Sneak”);
AngularSpeed = Animator.StringToHash(“AngularSpeed”);
Dead = Animator.StringToHash(“Dead”);
PlayerInSight = Animator.StringToHash(“PlayerInSight”);
Shot = Animator.StringToHash(“Shot”);
AimWeight = Animator.StringToHash(“AimWeight”);
LocomotionState = Animator.StringToHash(“Locomotion”);
}
}
###KeyPickup.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\KeyPickup.cs）
using UnityEngine;
using System.Collections;
public class KeyPickup:MonoBehaviour{
public AudioClip pickAud; //拾取到钥匙的声音
private PlayerInventory playerInventory;
void Awake(){
playerInventory = GameObject.FindWithTag(Tags.Player).GetComponent<PlayerInventory>();
}
void OnTriggerEnter(Collider other){
if(other.tag == Tags.Player){
playerInventory.hasKey = true; //更换标志位，玩家获取到了钥匙
AudioSource.PlayClipAtPoint(pickAud, transform.position); //播放声音
Destroy(gameObject); //销毁自己
}
}
}
###LaserController.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\LaserController.cs）
using UnityEngine;
using System.Collections;
public class LaserController:MonoBehaviour{
public bool isBlinking=false; //激光是否是闪动的
public float blinkDeltaTime=3f; //闪动间隔时间
private float timer=0; //计时器
private LastPlayerSighting lastPlayerSighting; //玩家警报脚本
void Awake(){
//找到玩家警报脚本
lastPlayerSighting = GameObject.FindWithTag(Tags.GameController).GetComponent<LastPlayerSighting>();
}
void Update(){
timer += Time.deltaTime; //计时器计时
//到达计时器时间
if(timer>= blinkDeltaTime && isBlinking){
timer = 0; //计时器归零
//控制激光组件的显影
GetComponent<MeshRenderer>().enabled = !GetComponent<MeshRenderer>().enabled;
GetComponent<Light>().enabled = !GetComponent<Light>().enabled;
GetComponent<AudioSource>().enabled = !GetComponent<AudioSource>().enabled;
GetComponent<BoxCollider>().enabled = !GetComponent<BoxCollider>().enabled;
}
}
//玩家触碰到激光
void OnTriggerEnter(Collider other){
//如果是玩家
if(other.tag ==Tags.Player){
//将玩家位置同步到警报位置
lastPlayerSighting.alarmPosition = other.transform.position;
}
}
}
###LaserSwitchDeactivation.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\LaserSwitchDeactivation.cs）
using UnityEngine;
using System.Collections;
public class LaserSwitchDeactivation:MonoBehaviour{
public GameObject controlledLaser; //所控制的激光
public Material unlockMat; //解锁的屏幕材质
//当玩家进入到电脑控制范围
void OnTriggerStay(Collider other){
//当玩家按下Z键
if(Input.GetKeyDown(KeyCode.Z) && other.tag ==Tags.Player && controlledLaser.activeSelf){
controlledLaser.SetActive(false); //关闭激光
GetComponent<MeshRenderer>().material = unlockMat; //切换屏幕材质
GetComponent<AudioSource>().Play();
}
}
}
###LastPlayerSighting.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\LastPlayerSighting.cs）
using UnityEngine;
using System.Collections;
public class LastPlayerSighting : MonoBehaviour{
public Vector3 alarmPosition = new Vector3(1000,1000,1000); //警报位置
public Vector3 normalPosition = new Vector3(1000,1000,1000); //非警报位置
public float turnSpeed=3f; //声音切换速度
private AlarmLight alarmLight; //警报灯脚本
private AudioSource mainAudio; //主背景音乐
private AudioSource panicAudio; //警报背景音乐
private AudioSource[] alarmAudios; //警报喇叭声音
void Awake(){
//找到警报灯脚本
alarmLight = GameObject.FindWithTag(Tags.AlarmLight).GetComponent<AlarmLight>();
mainAudio = GetComponent<AudioSource>(); //找到主背景音乐
//找到警报背景音乐
panicAudio = transform.GetChild(0).GetComponent<AudioSource>();
//先找到所有喇叭对象
GameObject[] sirens =GameObject.FindGameObjectsWithTag(Tags.Siren);
alarmAudios = new AudioSource[sirens.Length]; //初始化AudioSource数组
//获取所有喇叭对象中的AudioSource组件
for(inti =0; i< sirens.Length; i++){
alarmAudios[i] =sirens[i].GetComponent<AudioSource>();
}
}
void Update(){
//解除警报
if(alarmPosition == normalPosition){
alarmLight.alarmOn =false; //关闭警报灯
//渐渐关闭警报背景音乐
panicAudio.volume =Mathf.Lerp(panicAudio.volume,0,Time.deltaTime*turnSpeed);
//逐个渐渐关闭警报喇叭声音
for(inti=0; i <alarmAudios.Length; i++){
alarmAudios[i].volume = Mathf.Lerp(alarmAudios[i].volume,0,Time.deltaTime*turnSpeed);
}
//渐渐开启主背景音乐
mainAudio.volume = Mathf.Lerp(mainAudio.volume,1,Time.deltaTime*turnSpeed);
}else{ //开启警报
alarmLight.alarmOn =true; //开启警报灯
//渐渐关闭主背景音乐
mainAudio.volume = Mathf.Lerp(mainAudio.volume,0,Time.deltaTime*turnSpeed);
//渐渐开启警报背景音乐
panicAudio.volume = Mathf.Lerp(panicAudio.volume,1,Time.deltaTime*turnSpeed);
//渐渐开启警报喇叭声音
for(int i = 0; i < alarmAudios.Length; i++){
alarmAudios[i].voluem = Mathf.Lerp(alarmAudios[i].volume,1,Time.deltaTime*turnSpeed);
}
}
}
}
###LiftDoorsTracking.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\LiftDoorsTracking.cs）
using UnityEngine;
using System.Collections;
using UnityEngine.SceneManagement;
public class LiftDoorTracking:MonoBehaviour{
private float timer;
public float waitTime=1f;
public float moveTime=2f;
public float moveSpeed=3f;
private Transform player;
private AudioSource liftRaise;
private AudioSource endGame;
void Awake(){
player = GameObject.FindWithTag(Tags.Player).transform;
liftRaise = GetComponent<AudioSource>();
endGame = transform.parent.GetComponent<AudioSource>();
}
void OnTriggerStay(Collider other){
if(other.tag == Tags.Player){
timer += Time.deltaTime;
//到达上升时间
if(timer > waitTime){
//播放电梯声音
if(!liftRaise.isPlaying){
liftRaise.Play();
}
//播放结束游戏声音
if(!endGame.isPlaying){
endGame.Play();
}
//电梯上升
transform.root.position += Vector3.up*Time.deltaTime*moveSpeed;
//人物上升
player.position +=Vector3.up*Time.deltaTime*moveSpeed;
if(timer > waitTime+moveTime){
//TODO:重启游戏
SceneManager.LoadScene(“Yanlz_Demo006_Stealth”);
}
}
}
}
}
###PlayerHealth.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\PlayerHealth.cs）
using UnityEngine;
using System.Collections;
using UnityEngine.SceneManagement;
public class PlayerHealth:MonoBehaviour{
public float health =100; //玩家血量
public AudioClip endGameAud; //游戏结束声音
private Animator ani;
private bool isdead = false; //玩家是否死亡
private bool endGame = false; //游戏结束
void Awake(){
ani = GetComponent<Animator>();
}
public void TakeDamage(float damage){
health -= damage;
}
void Update(){
//如果血量小于等于0，死亡
if(health <=0&& !isdead){
ani.SetTrigger(HashIDs.Dead);
isdead = true;
}else if(isdead&& !endGame){
StartCoroutine(EndGame()); //开启结束游戏协程
endGame = true;
}
}
IEnumerator EndGame(){
AudioSource.PlayClipAtPoint(endGameAud,transform.position); //播放结束音效
yield return new WaitForSeconds(4.4f); //等待4.4秒
SceneManager.LoadScene(“Yanlz_Demo003_Stealth”);
}
}
###PlayerInventory.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\PlayerInventory.cs）
using UnityEngine;
using System.Collections;
public class PlayerInventory:MonoBehaviour{
public boolhasKey=false; //玩家是否拥有钥匙
}
###PlayerMovement.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\PlayerMovement.cs）
using UnityEngine;
using System.Collections;
//立钻哥哥:玩家控制脚本
public class PlayerMovement:MonoBehaviour{
public float turnSpeed=10; //转身速度
private float hor,ver; //操纵键变量
private bool sneak=false;
private Animator ani; //动画组件
private AudioSource aud; //声音组件
private PlayerHealth playerHealth;
void Awake(){
ani = GetComponent<Animator>();
aud = GetComponent<AudioSource>();
playerHealth = GetComponent<PlayerHealth>();
}
void Update(){
if(playerHealth.health>0){
//获取用户的按键情况
hor = Input.GetAxis(“Horizontal”);
ver = Input.GetAxis(“Vertical”);
}else{
hor = 0;
ver = 0;
}
if(Input.GetKey(KeyCode.LeftShift)){
sneak = true;
}else{
sneak = false;
}
//设置潜行参数
ani.SetBool(HashIDs.Sneak, sneak);
//如果用户按下了方向键
if(hor!=0 || ver!= 0){
//动画参数Speed渐变到5.5（奔跑动画）
ani.SetFloat(HashIDs.Speed,5.5f,0.1f, Time.deltaTime);
TurnDir(hor, ver); //玩家转向
}else{
ani.SetFloat(HashIDs.Speed,0); //立刻停下来
}
FootSteps(); //执行脚本声控制
}
//玩家转向
void TurnDir(float hor, float ver){
Vector3 dir = new Vector3(hor,0,ver); //拿到方向向量
//将方向向量转换成四元数（参考Y轴）
Quaternion qua = Quaternion.LookRotation(dir);
//玩家转向到该方向
transform.rotation =Quaternion.Lerp(transform.rotation,qua,Time.deltaTime*turnSpeed);
}
void FootSteps(){
//如果当前玩家正在播放Locomotion正常行走的动画
if(ani.GetCurrentAnimatorStateInfo(0).shortNameHash == HashIDs.LocomotionState){
//如果脚步声没有播放
if(!aud.isPlaying){
aud.Play(); //播放
}
}else{
aud.Stop(); //停止播放脚步声
}
}
}
###SyncDoor.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\SyncDoor.cs）
using UnityEngine;
using System.Collections;
public class SyncDoor:MonoBehaviour{
public Transform outterleft;
public Transform outterright;
private Transform innerleft;
private Transform innerright;
void Awake(){
innerleft = transform.GetChild(0);
innerright = transform.GetChild(1);
}
void Update(){
//左右里门同步左右外门
innerleft.localPosition = new Vector3(innerleft.localPosition.x,innerleft.localPosition.y,outterleft.localPosition.z);
innerright.localPosition = new Vector3(innerright.localPosition.x,innerright.localPosition.y,outterright.localPosition.z);
}
}
###Tags.cs
（D:\zz_DemoPro()-\小案例006、秘密行动Demo\Demo006_StealthActionDemo\Assets\Scripts\Tags.cs）
using UnityEngine;
using System.Collections;
//立钻哥哥：标签管理
public class Tags{
public const stringAlarmLight=“AlarmLight”;
public const stringSiren= “Siren”;
public const stringPlayer=“Player”;
public const string GameController=“GameController”;
public const string Enemy=“Enemy”;
}
#小案例007、A_Star
++小案例007、A_Star
++++FindPath.cs
++++GridMap.cs
++++Node.cs
###FindPath.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class FindPath : MonoBehaviour{
private GridMap _grid; //整张地图
public Transform startPoint, endPoint;
private void Start(){
_grid = GameObject.FindObjectOfType<GridMap>();
}
private void Update(){
FindingPath(startPoint.position, endPoint.position);
}
//立钻哥哥：核心算法：生成路径
private void FindingPath(Vector3 startPos,Vector3 EndPos){
//获取起点和终点的格子
Node startNode = _grid.GetNodeFromPosition(StartPos);
Node endNode = _grid.GetNodeFromPosition(EndPos);
//创建开启列表和关闭列表
List<Node> openSet =new List<Node>();
HashSet<Node>closeSet =new HashSet<Node>();
openSet.Add(startNode);
while(openSet.Count>0){
Node currentNode =openSet[0]; //从开启列表中随便取出一个节点
//取最小的节点
for(int i=0; i < openSet.Count; i++){
if(openSet[i].fCost < currentNode.fCost){
currentNode = openSet[i];
}
}
//从开启列表移除，加入关闭列表
openSet.Remove(currentNode);
closeSet.Add(currentNode);
//找到终点
if(currentNode == endNode){
GeneratePath(startNode, endNode); //生成一条路径
return;
}
foreach(var node in _grid.GetNeibourhood(currentode)){
if(!node._canWalk||closeSet.Contains(node)){
continue;
}
//计算与相邻格子的距离
int newCost = currentNode.gCost + GetDistance(currentNode,node);
if(newCost <node.gCost || !openSet.Contains(node)){
node.gCost =newCost;
node.hCost = GetDistance(node,endNode);
node.parent = currentNode;
if(!openSet.Contains(node)){
openSet.Add(node);
}
}
}
}
}
//计算两点间的距离
int GetDistance(Node a, Nodeb){
int cntX= Mathf.Abs(a._gridX-b._gridX);
int cntY =Mathf.Abs(a._gridY-b._gridY);
if(cntX>cntY){
return 14*cntY+10* (cntX-cntY);
}else{
return 14*cntX+10* (cntY-cntX);
}
}
//生成最终路径
private void GeneratePath(Node startNode,Node endNode){
List<Node> path =new List<Node>();
Node temp = endNode;
while(temp !=startNode){
path.Add(temp);
temp = temp.parent;
}
path.Reverse();
_grid.path=path;
}
}
###GridMap.cs
（D:\yanlz_DemoPro()-\小案例007、AStar\Assets\GridMap.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class GridMap:MonoBehaviour{
private Node[,] grid; //存放所有格子的容器
[Tooltip(“地图的尺寸”)]
public Vector2 gridSize;
[Tooltip(“每个格子的半径”)]
public float nodeRadius;
//直径
private float nodeDiamenter{
get{ return nodeRadius*2; }
}
[Tooltip(“障碍物所在的层”)]
public LayerMask ObstacleLayer;
private int gridCntX,gridCntY; //地图上横纵格子数量
public List<Node>path = new List<Node>(); //最终路径
private void Start(){
gridCntX = Mathf.RoundToInt(gridSize.x /nodeDiameter);
gridCntY = Mathf.RoundToInt(gridSize.y /nodeDiameter);
grid = newNode[gridCntX,gridCntY];
CreateGrid();
}
//立钻哥哥：创建节点
private void CreateGrid(){
Vector3 startPoint = transform.position-gridSize.x /2 *Vector3.right-Vector3.forward*gridSize.y /2;
for(int i=0; i < gridCntX; i++){
for(intj =0; j < gridCntY; j++){
//每个格子的世界坐标
Vector3 worldPoint = startPoint+ Vector3.right* (i *nodeDiameter+nodeRadius) +Vector3.forward* (j *nodeDiameter+nodeRadius);
//格子上是否有障碍物
bool canWalk = !Physics.CheckSphere(wordPoint,nodeRadius,ObstacleLayer);
grid[i,j] = new Node(canWalk,worldPoint,i,j);
}
}
}
//立钻哥哥：Unity回调
private void OnDrawGizmos(){
if(Application.isPlaying==false){
return;
}
if(gird ==null){
return;
}
foreach(var node in grid){
Gizmos.color = node._canWalk?Color.gray:Color.red; //指定颜色
//绘制图形
Gizmos.DrawCube(node._wordPos, (nodeDiameter -nodeDiameter*0.1f) *Vector3.one);
}
if(path !=null){
foreach(var node in path){
Gizmos.color = Color.green;
Gizmos.DrawCube(node._wordPos, (nodeDiameter -nodeDiameter*0.1f) *Vector3.one);
}
}
}
//根据世界位置，得到Node
public Node GetNodeFromPosition(Vector3 position){
float percentX = (position.x +gridSize.x /2) / gridSize.x;
float percentY = (position.z +gridSize.y /2) / gridSize.y;
percentX = Mathf.Clamp01(percentX);
percentY = Mathf.Clamp01(percentY);
int x = Mathf.RoundToInt((gridCntX-1) *percentX);
int y = Mathf.RoundToInt((gridCntY-1) *percentY);
return grid[x,y];
}
//获取一个格子周围的8个格子
public List<Node> GetNeibourhood(Node node){
List<Node> neibourhood= new List<Node>();
for(inti = -1; i <=1; i++){
for(int j = -1; j <= 1; j++){
if(i ==0&& j==0){
continue;
}
int tempX= node._gridX+i;
int tempY= node._gridY+j;
if(tempX < gridCntX && tempX > 0 && tempY> 0 &&tempY<gridCntY){
neibourhood.Add(grid[tempX,tempY]);
}
}
}
return neibourhood;
}
}
###Node.cs
（D:\yanlz_DemoPro()-\小案例007、AStar\Assets\Node.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
//立钻哥哥：格子数据结构
//Node: 一个小格子
//GridMap: 整张地图
//FindPath: 根据A*算法，生成的路径
public class Node{
public int gCost;
public int hCost;
public int fCost{
get{ return gCost+hCost; }
}
public Node parent; //指向父格子的指针
public int _gridX,_gridY; //格子序号
public bool _canWalk; //格子上方是否有障碍物
public Vector3 _worldPos; //格子所在的世界坐标
public Node(bool Canwalk, Vector3 position, int x, int y){
_canWalk = Canwalk;
_worldPos = position;
_gridX = x;
_gridY = y;
}
}
#小案例008、血条LiftBar跟随
++小案例008、血条LiftBar跟随
++++FaceToCamera.cs
++++HeadHP.cs
++++HPTest.cs
++++PlayerMove.cs
###FaceToCamera.cs
（D:\yanlz_DemoPro()-\小案例008、血条LiftBar跟随\Assets\FaceToCamera.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class FaceToCamera :MonoBehaviour{
private Camera camera;
void Start(){
camera = Camera.main;
}
//立钻哥哥：Update is called once per frame
void Update(){
Vector3 pos= camera.transform.position-transform.position;
pos.x = pos.z = 0;
transform.LookAt(camera.transform.position-pos);
transform.Rotate(0,180,0);
}
}
###HeadHP.cs
（D:\yanlz_DemoPro()-\小案例008、血条LiftBar跟随\Assets\HeadHP.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class HeadHP:MonoBehaviour{
private Image image;
private int hp=150;
private int maxhp;
void Start(){
image = GetComponent<Image>();
maxhp = hp;
}
void Update(){
if(Input.GetKeyDown(KeyCode.Space)){
hp -= 10;
image.fillAmout = (float)hp/maxhp;
}
}
}
###HPTest.cs
（D:\yanlz_DemoPro()-\小案例008、血条LiftBar跟随\Assets\HPTest.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class HPTest:MonoBehaviour{
private RectTransform rectTrans;
public Transform target;
public Vector2 offsetPos;
void Start(){
rectTrans = GetComponent<RectTransform>();
}
void Update(){
Vector3 postar =target.transform.position;
Vector2 pos=RectTransformUtility.WorldToScreenPoint(Camera.main,postar);
rectTrans.position =pos+offsetPos;
}
}
###PlayerMove.cs
（D:\yanlz_DemoPro()-\小案例008、血条LiftBar跟随\Assets\PlayerMove.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
public class PlayerMove:MonoBehaviour{
private NavMeshAgent nav;
void Start(){
nav = GetComponent<NavMeshAgent>();
}
void Update(){
if(Input.GetMouseButtonDown(0)){
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
Raycasthit hit;
if(Physics.Raycast(ray, out hit)){
nav.SetDestination(hit.point);
}
}
}
}
#小案例009、见缝插针StickPin
#小案例009、见缝插针StickPin
++++GameManager.cs
++++Pin.cs
++++PinHead.cs
++++RotateSelf.cs
###GameManager.cs
（D:\yanlz_DemoPro()-\小案例009、见缝插针StickPin\Assets\Scripts\GameManager.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
public class GameManager:MonoBehaviour{
private Transform startPoint;
private Transform spawnPoint;
private Pin currentPin;
private bool isGameOver=false;
private int score =0;
private Camera mainCamera;
public Text scoreText;
public GameObject pinPrefab;
public float speed =3;
void Start(){
startPoint = GameObject.Find(“StartPoint”).transform;
spawnpoint = GameObject.Find(“SpawnPoint”).transform;
mainCamera = Camera.main;
SpawnPin();
}
private void Update(){
if(isGameOver){
return;
}
if(Input.GetMouseButtonDown(0)){
score++;
scoreText.text = score.ToString();
currentPin.StartFly();
SpawnPin();
}
}
void SpawnPin(){
currentPin = GameObject.Instantiate(pinPrefab,spawnPoint.position,pinPrefab.transform.rotation).GetComponent<Pin>();
}
public void GameOver(){
if(isGameOver){
return;
}
GameObject.Find(“Circle”).GetComponent<RotateSelf>().enabled = false;
StartCoroutine(GameOverAnimation());
isGameOver = true;
}
IEnumerator GameOverAnimation(){
while(true){
mainCamera.backgroundColor = Color.Lerp(mainCamera.backgroundColor,Color.red, speed* Time.deltaTime);
mainCamera.orthographicSize=Mathf.Lerp(mainCamera.orthographicSize, 4, speed*Time.deltaTime);
if(Mathf.Abs(mainCamera.orthographicSize-4) <0.01f){
break;
}
yield return 0;
}
yield return new WaitForSeconds(0.2f);
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
}
}
###Pin.cs
（D:\yanlz_DemoPro()-\小案例009、见缝插针StickPin\Assets\Scripts\Pin.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Pin:MonoBehaviour{
public float speed= 5;
private bool isFly =false;
private bool isReach =false;
private Transform startPoint;
private Vector3 targetCirclePos;
private Transform circle;
void Start(){
startPoint = GameObject.Find(“StartPoint”).transform;
//circle = GameObject.Find(“Circle”).transform;
circle = GameObject.FindGameObjectWithTag(“Circle”).transform;
targetCirclePos = circle.position;
targetCirclePos.y -= 1.55f;
}
void Update(){
if(isFly ==false){
if(isReach==false){
transform.position = Vector3.MoveTowards(transform.position, startPoint.position, speed*Time.deltaTime);
if(Vector3.Distance(transform.position, startPoint.position) <0.05f){
transform.position = targetCirclePos;
transform.parent =circle;
isFly =false;
}
}
}
}
public void StartFly(){
isFly = true;
isReach = true;
}
}
###PinHead.cs
（D:\yanlz_DemoPro()-\小案例009、见缝插针StickPin\Assets\Scripts\PinHead.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PinHead:MonoBehaviour{
private void OnTriggerEnter2D(Collider2D collision){
if(collision.tag ==“PinHead”){
GameObject.Find(“GameManger”).GetComponent<GameManager>().GameOver();
}
}
}
###RotateSelf.cs
（D:\yanlz_DemoPro()-\小案例009、见缝插针StickPin\Assets\Scripts\RotateSelf.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class RotateSelf:MonoBehaviour{
public float speed=90;
void Update(){
transform.Rotate(new Vector3(0,0, -speed* Time.deltaTime));
}
}
#小案例010、UnityNetDemo
#小案例010、UnityNetDemo
++++Player.cs
###Player.cs
（D:\yanlz_DemoPro()-\小案例010、UnityNetDemo\Assets\Player.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;
public class Player :NetworkBehaviour{
public float rotSpeed=150f;
public float movSpeed= 3.0f;
private float hor,ver;
publicGameObject bulletPrefab;
publicTransform bulletSpawn;
voidUpdate(){
if(!isLocalPlayer){
return;
}
PlayerMove();
if(Input.GetKeyDown(KeyCode.Space)){
CmdFire();
}
}
[Command]
void CmdFire(){
GameObject bullect =Instantiate<GameObject>(bulletPrefab,bulletSpawn.position,bullectSpawn.rotation);
bullect.GetComponent<Rigidbody>().velocity = bullet.transform.forward*6;
NetworkServer.Spawn(bullect);
Destroy(bullet,2f);
}
void PlayerMove(){
hor = Input.GetAxis(“Horizontal”) * Time.deltaTime*rotSpeed;
ver = Input.GetAxis(“Vertical”) * Time.deltaTime*movSpeed;
transform.Rotate(0, hor, 0);
transform.Translate(0,0, ver);
}
public override void OnStartLocalPlayer(){
GetComponent<MeshRenderer>().material.color= Color.green;
}
}
#小案例011、SocketFileRecv
#小案例011、SocketFileRecv
++++Server\Program.cs
++++Client\Program.cs
###Server\Program.cs
（D:\yanlz_DemoPro()-\小案例011、socketFileRecv\Server\ConsoleApp1\Program.cs）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Server{
class Program{
static void Main(string[] args){
Myserver server = newMyserver();
server.Start();
}
}
class Myserver{
Socket serverSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
IPEndPoint point = new IPEndPoint(IPAddress.Any,12345);
public void Start(){
serverSocket.Bind(point);
serverSocket.Listen(10);
Console.WriteLine(“立钻哥哥Print:服务器启动成功”);
Thread acceptThread = new Thread(Accept);
acceptThread.IsBackground =true;
acceptThread.Start();
Console.ReadKey();
}
void Accept(){
Socket client = serverSocket.Accept();
IPEndPoint point = client.RemoteEndPointas IPEndPoint;
Console.WriteLine(point.Address +“[” + point.Port +“]连接成功”);
Thread receiveThread = new Thread(Receive);
receiveThread.IsBackground= true;
receiveThread.Start(client);
Accept();
}
public void Receive(objectobj){
Socket client = objas Socket;
IPEndPoint point= client.RemoteEndPointas IPEndPoint;
byte[]msg =newbyte[1024];
int length= client.Receive(msg);
Console.WriteLine(point.Address +“[” + point.Port +“]” + Encoding.UTF8.GetString(msg, 0, length));
Receive(client);
}
}
}
###Client\Program.cs
（D:\yanlz_DemoPro()-\小案例011、socketFileRecv\Client\ConsoleApp2\Program.cs）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
namespace Client{
class Program{
static void Main(string[] args){
MyClient client = newMyClient();
client.Connect(“127.0.0.1”,12345);
Console.WriteLine(“立钻哥哥Print:请输入内容”);
string msg = Console.ReadLine();
while(msg!= “q”){
client.Send(msg);
msg =Console.ReadLine();
}
}
class MyClient{
Socket clientSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
public void Connect(stringip,int port){
clientSocket.Connect(ip,port);
Console.WriteLine(“立钻哥哥Print:连接成功”);
}
public void Send(string msg){
clientSocket.Send(Encoding.UTF8.GetBytes(msg));
}
}
}
}
#小案例012、切水果CutFruitDemo
#小案例012、切水果CutFruitDemo
++++MouseControl.cs
++++DestroyOnTime.cs
++++ObjectControl.cs
++++Spawner.cs
++++UIOver.cs
++++UIScore.cs
++++UIStart.cs
###MouseControl.cs
（D:\yanlz_DemoPro()-\小案例012、切水果CutFruitDemo\Assets\MouseControl.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class MouseControl:MonoBehaviour{
LineRenderer lineRenderer;
Vector3[] positions=new Vector3[10];
bool firstMouse;
bool MouseDown;
Vector3 head;
Vector3 last;
int posCount;
private voidStart(){
lineRenderer = GetComponent<LineRenderer>();
}
private void Update(){
if(Input.GetMouseButtonDown(0)){
firstMouse = true;
MouseDown = true;
}
if(Input.GetMouseButtonUp(0)){
MouseDown = false;
}
OnDrawLine();
firstMouse=false;
}
private void OnDrawLine(){
if(firstMouse){
posCount = 0;
head = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePositon.x,Input.mousePosition.y,12.9f));
last = head;
}
if(MouseDown){
head = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x,Input.mousePosition.y,12.9f));
if(Vector3.Distance(head,last) > 0.01f){
SavePosition(head);
posCount++;
OnRayCast(head);
}
last=head;
}else{
positions = new Vector3[10];
}
ChangePositions(positions);
}
void SavePosition(Vector3 pos){
if(posCount <= 9){
for(inti =posCount; i <=9; i++){
positions[i] =pos;
}
}else{
for(int i =0; i<9; i++){
positions[i] =positions[i +1];
positions[9] =pos;
}
}
}
void ChangePositions(Vector3[ ] positions){
linerRenderer.SetPositions(positions);
}
void OnRayCast(){
Vector3 screenPosition = Camera.main.WorldToScreenPoint(pos);
Ray ray = Camera.main.ScreenPointToRay(screenPosition);
RaycastHit[]hits =Physics.RaycastAll(ray);
for(int i =0; i <hits.Length; i++){
hits[i].collider.gameObject.SendMessage(“OnCut”,SendMessageOptions.DontRquireReceiver);
}
}
}
###DestroyOnTime.cs
（D:\yanlz_DemoPro()-\小案例012、切水果CutFruitDemo\Assets\Scripts\DestroyOnTime.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//立钻哥哥：按照时间销毁
public class DestroyOnTime:MonoBehaviour{
public float desTime=2f;
void Start(){
Invoke(“Dead”, desTime);
}
void Dead(){
Destroy(gameObject);
}
}
###ObjectControl.cs
（D:\yanlz_DemoPro()-\小案例012、切水果CutFruitDemo\Assets\Scripts\ObjectControl.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//立钻哥哥：物体控制脚本
public class ObjectControl:MonoBehaviour{
public GameObject halfFruit; //一半的水果
public GameObject Splash;
public GameObject SplashFlat;
public GameObject Firework;
private bool dead=false;
public AudioClip ac;
//被切割的时候调用
public void OnCut(){
//防止重复调用
if(dead){
return;
}
if(gameObject.name.Contains(“Bomb”)){
//生成特效
Instantiate(Firework,transform.position,Quaternion.identity)
UIScore.Instance.Remove(20); //如果是炸弹，就需要扣分
}else{
//先生成被切割的水果
for(inti = 0; i <2; i++){
GameObject go= Instantiate<GameObject>(halfFruit,transform.position,Random.rotation);
go.GetComponent<Rigidbody>().AddForce(Random.onUnitSphere*5f,ForceMode.Impulse);
}
//生成特效
Instantiate(Splash,transform.position,Quaternion.identity);
Instantiate(SplashFlat,transform.position,Quaternion.identity);
UIScore.Instance.Add(10); //如果是水果，就加分
}
AudioSource.PlayClipAtPoint(ac,transform.position);
Destroy(gameObject); //销毁自身
dead = true;
}
}
###Spawner.cs
（D:\yanlz_DemoPro()-\小案例012、切水果CutFruitDemo\Assets\Scripts\Spawner.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//立钻哥哥：用来产生水果、炸弹等（也让它能控制销毁）
public class Spawner:MonoBehaviour{
[Header(“水果的预设”)]
public GameObject[] Fruits;
[Header(“炸弹的预设”)]
public GameObject Bomb;
public AudioSource audioSource; //播放声音的组件
float spawnTime = 3f; //产生时间
bool isPlaying = true; //是否在玩游戏
void Update(){
if(!isPlaying){
return;
}
spawnTime-= Time.deltaTime;
if(0 >spawnTime){
//到时间了就开始产生水果
int fruitCount= Random.Range(1,5);
for(inti=0; i <fruitCount; i++){
onSpawn(true);
}
//随机产生炸弹
int bombNum = Random.Range(0,100);
if(bombNum>10){
onSpawn(false);
}
spawnTime=3f;
}
}
private int tmpZ=0; //临时存储当前水果的z坐标
//产生水果和炸弹
//param isFruit:是否是水果
private void onSpawn(bool isFruit){
this.audioSource.Play(); //播放音乐
//x范围：-8.4~8.4
//y范围：transform.pos.y
//得知坐标范围
float x =Random.Range(-8.4f, 8.4f);
float y = transform.position.y;
float z =tmpZ;
//tmpZ -= 2;
tmpZ = tmpZ-2; //使水果不在一个平面上
if(tmpZ<= -10){
tmpZ = 0;
}
//实例化水果
int fruitIndex =Random.Range(0, Fruits.Length);
GameObject go;
if(isFruit){
go = Instantiate<GameObject>(Fruits[fruitIndex],new Vector3(x,y,z),Random.rotation);
}else{
go = Instantiate<GameObject>(Bomb,new Vector3(x,y,z),Random.rotation)
}
//水果的速度
Vector3 velocity =new Vector3(-x *Random.Range(0.2f,0.8f), -Physics.gravity.y *Random.Range(1.2f,1.5f),0);
//Rigidbody rigidbody = transform.GetComponent<Rigibody>();
Rigidbody rigidbody = go.GetComponent<Rigidbody>();
rigidbody.velocity= velocity;
}
//有物体碰撞的时候调用
private void OnCollisionEnter(Collision other){
Destroy(other.gameObject);
}
}
###UIOver.cs
（D:\yanlz_DemoPro()-\小案例012、切水果CutFruitDemo\Assets\Scripts\UIOver.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
public class UIOver :MonoBehaviour{
public UnityEvent events;
public void OnClick(){
UnityEngine.SceneManagement.SceneManager.LoadScene(0);
}
}
###UIScore.cs
（D:\yanlz_DemoPro()-\小案例012、切水果CutFruitDemo\Assets\Scripts\UIScore.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class UIScore:MonoBehaviour{
public static UIScore Instance=null; //立钻哥哥：单例对象
void Awake(){
Instance = this;
}
[SerializeField]
private Text txtScore;
private int score = 0; //当前多少分
//加分
public void Add(int score){
this.score += score;
textScore.text = this.score.ToString();
}
//扣分
public void Remove(int score){
this.score -= score;
//如果分数小于0，那么游戏结束
if(this.score <= 0){
UnityEngine.SceneManagement.SceneManager.LoadScene(“over”);
return;
}
textScore.text =this.score.ToString();
}
}
###UIStart.cs
（D:\yanlz_DemoPro()-\小案例012、切水果CutFruitDemo\Assets\Scripts\UIStart.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
public class UIStart:MonoBehaviour{
private Button btnPlay; //开始按钮
private Button btnSound; //声音按钮
private AudioSource audioSourceBG; //背景音乐播放器
private Image imgSound; //声音的图片
public Sprite[] soundSprites; //声音的图片
void Start(){
getCompnents();
btnPlay.onClick.AddListener(onPlayClick);
bthSound.onClick.AddListener(onSoundClick);
}
void OnDestroy(){
btnPlay.onClick.RemoveListener(onPlayClick);
btnPlay.onClick.RemoveListener(onSoundClick);
}
//寻找组件
private void getComponents(){
btnPlay = transform.Find(“btnPlay”).GetComponent<Button>();
btnSound = transform.Find(“btnSound”).GetComponent<Button>();
audioSourceBG = transform.Find(“btnSound”).GetComponent<AudioSource>();
imgSound = transform.Find(“btnSound”).GetComponent<Image>();
}
//当开始按钮按下的点击事件
void onPlayClick(){
SceneManager.LoadScene(“play”,LoadSceneMode.Single);
}
//当声音按钮点击时候调用
void onSoundClick(){
if(audioSourceBG.isPlaying){
//正在播放
audioSourceBG.Pause();
imgSound.sprite=soundSprites[1];
}else{
//停止播放
audioSourceBG.Play();
imgSound.sprite=soundSprites[0];
}
}
}
#小案例013、吃鸡_友军方位UV
#小案例013、吃鸡_友军方位UV
++++CoordScript.cs
++++FriendMoveScript.cs
++++CameraScript.cs
###CoordScript.cs
（D:\yanlz_DemoPro()-\小案例013、吃鸡_友军方位UV\FriendCoordTest\Assets\CoordScript.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using UnityEngine.UI;
public class CoordScript:MonoBehaviour{
RawImage rawImage;
public Transform friendTrans; //友军
public Transform friendImg; //友军Image
float width;
private void Start(){
rawImage = GetComponent<RawImage>();
width = transform.GetComponent<RectTransform>().rect.width;
}
private void Update(){
Rect tmpRect = new Rect(GetY(Camera.main.transform.eulerAngles.y),0.38f,1,1);
rawImage.uvRect =tmpRect;
//相机的投影前方
Vector3 cameraForward =new Vector3(Camera.main.transform.forward.x,0,Camera.main.transform.forward.z);
//计算与友军的夹角
Vector3 dir = friendTrans.position-Camera.main.transform.position;
dir = new Vector3(dir.x, 0, dir.z);
float angle= Vector3.Angle(cameraForward,dir);
//计算友军左右
Vector3 normal =Vector3.Cross(cameraForward,dir);
angle = normal.y<0 ?360-angle : angle; //计算最终夹角
float percent =GetYY(angle); //根据角度（0-1）的percent
float x =percent* width - width/2; //变换
friendImg.transform.localPosition =new Vector3(x, -30,0);
}
private float GetY(float x){
return (1 /360.0f) * (x %360) + 0.5f;
}
private float GetYY(float x){
return ((1 /180.0f) *x /2 +0.5f) %1;
}
}
###FriendMoveScript.cs
（D:\yanlz_DemoPro()-\小案例013、吃鸡_友军方位UV\FriendCoordTest\Assets\FriendMoveScript.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class FriendMoveScript:MonoBehaviour{
private void Update(){
transform.RotateAround(Vector3.zero,Vector3.up, Time.deltaTime*90f);
}
}
###CameraScript.cs
（D:\yanlz_DemoPro()-\小案例013、吃鸡_友军方位UV\FriendCoordTest\Assets\Scripts\Application\CameraScript.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class CameraScript:MonoBehaviour{
public Transform y_Axis;
public Transform x_Axis;
public Transform z_Axis;
public Transform zoom_Axis;
public Transform player;
float hor,ver,scrollWheel;
public float roSpeed=180;
public float scSpeed=5f;
float upLimitAngle=60f;
float downLimitAngle=0;
public bool followFlag=true;
float x = 0;
floatsc= 8,minDis= 1,maxDis=12;
void LateUpdate(){
hor = Input.GetAxis(“Mouse X”);
ver = Input.GetAxis(“Mouse Y”);
scrollWheel = Input.GetAxis(“Mouse ScrollWheel”);
//水平旋转
if(hor != 0){
y_Axis.Rotate(Vector3.up*roSpeed* hor *Time.deltaTime);
}
//垂直旋转
if(ver!= 0){
x -= ver*Time.deltaTime*roSpeed;
x = Mathf.Clamp(x, -downLimitAngle,upLimitAngle);
Quaternion q =Quaternion.identity;
q = Quaternion.Euler(new Vector3(x,x_Axis.eulerAngles.y,x_Axis.eulerAngles.z));
x_Axis.rotation=q;
}
//缩放
if(scrollWheel != 0){
sc -= scrollWheel*Time.deltaTime*scSpeed;
zoom_Axis.transform.localPosition = new Vector3(0,0,Mathf.Clamp(-sc, -maxDis, -minDis));
}
//跟随玩家
if(followFlag){
y_Axis.position = player.position + Vector3.up*1.7f;
}
//控制玩家旋转
//player.forward = new Vector3(transform.forward.x, 0, transform.forward.z);
}
}
#小案例014、数据库背包SqliteEZ_Bag
#小案例014、数据库背包SqliteEZ_Bag
++++DataBaseController.cs
++++HeroMessage.cs
++++SqliteDataScripts.cs
++++StoreWeapon.cs
++++WeaponBox.cs
###DataBaseController.cs
（D:\yanlz_DemoPro()-\小案例014、SqliteEZ_Bag\Assets\DataBaseController.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Mono.Data.Sqlite;
//立钻哥哥：封装数据库
public class DataBaseController:MonoBehaviour{
public static DataBaseController instance; //单例脚本对象
private string sqlitePath; //数据库地址
private SqliteConnection con; //连接
private SqliteCommand command;
private SqliteDataReader reader;
void Awake(){
instance = this;
}
//连接数据库
//param databaseName:数据库名称
public void ConnectToSqlite(string databaseName){
string connectDatabaseName = databaseName; //获取数据库名称
//判断数据库名称中是否包含.sqlite
if(!connectDatabaseName.Contains(“.sqlite”)){
connectDatabaseName +=“.sqlite”; //如果不包含就添加
}
//拼接数据库连接路径
sqlitePath =“Data Source=” +Application.streamingAssetsPath+“/” +connectDatabaseName;
con = new SqliteConnection(sqlitePath); //实例化数据库连接对象
command = con.CreateCommand(); //创建数据库指令对象
try{
con.Open(); //打开数据库
print(“立钻哥哥Print:数据库打开成功”);
}catch(SqliteException ex){
//抛出异常
Debug.Log(“立钻哥哥Print:----异常：” + ex);
}
}
//关闭数据库
public void CloseSqliteConnection(){
try{
//如果连接对象不为空
if(con != null){
con.Close(); //关闭数据库
}
}catch(SqliteExceptionex){
Debug.Log(“----” + exsss);
}
}
//查询属性信息
//param isHero:查询的是否是人物的属性
//param name:人物名称或者装备名称
public float[]SelectHeroMsg(bool isHero,string name){
try{
float[] result=newfloat[4]; //result:用于存储结果
string selectQuery; //查询
//如果查询的是人物的属性
if(isHero){
selectQuery =“select AD,AP,AR,MP from hero where HeroName =‘”+name+”’”;
}else{
selectQuery =“select AD,AP,AR,MP from Equip where EquipName =‘”+name+”’”
}
command.CommandText =selectQuery;
//执行sql语句
reader= command.ExecuteReader();
//读取第一行数据
while(reader.Read()){
//遍历获取的结果
//根据字段的个数进行遍历
for(int i =0; i <reader.FieldCount; i++){
result[i] =System.Convert.ToSingle(reader.GetValue(i));
}
}
reader.Close(); //关闭连接
return result; //返回结果
}catch(SqliteException ex){
Debug.Log(“立钻哥哥Print:出错了~~~” + ex);
return null;
}
}
//添加或者移除装备
public float[] AddOrRemoveProperty(boolisAdd, float[] heroProperty, float[] equipProperty){
try{
if(heroProperty.Length==4 &&equipProperty.Length==4){
float[] result =new float[4]; //创建结果数组，保存结果
//如果是添加装备
if(isAdd){
//遍历添加赋值
for(int i =0; i <result.Length; i++){
result[i] =heroProperty[i] +equipProperty[i];
}
}else{
//遍历移除赋值
for(inti =0; i<result.Length; i++){
result[i] =heroProperty[i] -equipProperty[i];
}
}
return result; //将结果返回
}else{
Debug.Log(“立钻哥哥Print:出错了，属性个数不匹配”);
return null;
}
}catch(SqliteException ex){
Debug.Log(“----异常：” + ex);
return null;
}
}
//更新数据库中英雄的属性信息
//param newHeroProperty:新的人物属性信息
//param heroName:人物名称
public void UpdateHeroProperty(float[] newHeroProperty, string heroName){
try{
//更新人物属性信息sql语句
string updateQuery =“update hero set ad=” + newHeroProperty[0]
+“,ap=” +newHeroProperty[1]
+“,ar=” +newHeroProperty[2]
+“,mp” +newHeroProperty[3]
+“ where heroname=’”+heroName+”’”
command.CommandText = updateQuery; //赋值给指令对象
command.ExecuteNonQuery(); //执行sql语句：增删改操作
}catch(SqliteException ex){
Debug.Log(“----出错了：” + ex);
}
}
//直接通过SQL语句去查询一个结果
//returns:查询到的单个数据
//param query：SQL语句
public object SelectSingle(string query){
try{
command.CommandText =query; //赋值SQL语句
object obj =command.ExecuteScalar(); //执行查询语句
return obj; //返回结果
}catch(SqliteExceptionex){
Debug.Log(“立钻哥哥Print: ----异常：” + ex);
return null;
}
}
//查询更多数据
//returns:数据结果
//param query: SQL语句
public List<ArrayList> SelectMore(string query){
try{
List<ArrayList> result =new List<ArrayList>(); //创建结果数组
command.CommandText= query; //赋值SQL语句
reader = command.ExecuteReader(); //执行
while(reader.Read()){
ArrayList temp =new ArrayList(); //实例化临时集合
for(int i =0; i <reader.FieldCount; i++){
temp.Add(reader.GetValue(i)); //将结果添加到集合中
}
result.Add(temp); //将临时集合添加到泛型集合（result）中
}
return result; //返回最终结果
}catch(SqliteException ex){
Debug.Log(“立钻哥哥Print:异常：” + ex);
return null;
}
}
}
###HeroMessage.cs
（D:\yanlz_DemoPro()-\小案例014、SqliteEZ_Bag\Assets\HeroMessage.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
//立钻哥哥：展示人物基础属性
public class HeroMessage:MonoBehaviour{
private Text uiText;
void Awake(){
uiText = transfrom.GetChild(0).GetComponent<Text>();
}
//更新人物UI的信息
//parma msg:人物信息数组
public void UpdateUIMessage(float[] msg){
//UIText赋值
uiText.text = “攻击力” +msg[0] +“\n” +
“法强：” +msg[1] +“\n” +
“护甲：” +msg[2] +“\n” +
“魔抗” +msg[3];
}
void Start(){
DataBaseController.instance.ConnectToSqlite(“LOL”); //连接数据库
//查询数据
float[] heroMsg= DataBaseController.instance.SelectHeroMsg(true, “EZ”);
UpdateUIMessage(heroMsg); //展示
DataBaseController.instance.CloseSqliteConnection(); //关闭数据库
}
}
###SqliteDataScripts.cs
（D:\yanlz_DemoPro()-\小案例014、SqliteEZ_Bag\Assets\SqliteDataScript.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Data;
using Mono.Data.Sqlite;
public class SqliteDataScript:MonoBehaviour{
private string path; //指定路径
void Start(){
path = Application.dataPath +“/weapon.sqlite”; //1、数据存储的路径
//2、创建数据库连接（Data Source:数据源）
SqliteConnection connection =new SqliteConnection(“Data Source=” +path);
connection.Open(); //3、打开数据库
//4、创建指令对象（真正执行sql语句）
SqliteCommand command =connection.CreateCommand();
//5、将sql语句设置给指令对象
//string InsertStr =“insert into hero values(‘立钻哥哥’,10,8,100)”; //插入
//string InsertStr =“insert into hero values(‘亦菲妹妹’,10,8,100)”;
//string InsertStr =“insert into hero(‘heroname’,’ap’,’ad’,’level’)values(‘大哥哥’,10,8,100)”;
//string DeleStr =“delete from hero where level <5”; //删除
//string UpdateStr =“update hero set AP=1000 where rowid=2”; //修改
string SleStr =“select * from hero”; //查询
command.CommandText =SleStr;
//6、让指令对象去执行sql语句
//ExecuteNonQuery:只作为增，删，改操作，不做查询
command.ExecuteNonQuery();
//查询方法1：ExecuteScalar
//command.ExecuteScalar(); //返回所有结果中的第一个查询到的值
//查询方法2：ExecuteReader
//SqliteDataReader：查询到的所有值都会存储到SqliteDataReader中
SqliteDataReader reader= command.ExecuteReader();
//Read: 处理结果集（只要执行一次就会读取结果中的一行数据）
while(reader.Read()){
string name1 =reader.GetString(0); //取出字段值
int ap1= reader.GetInt16(1);
int ad1 =reader.GetInt16(2);
int level1 =reader.GetInt16(3);
print(string.Format(“name:{0},ap{1},ad{2},level:{3}”,name1,ap1,ad1,level1));
}
connection.Close(); //7、关闭数据库
}
}
###StoreWeapon.cs
（D:\yanlz_DemoPro()-\小案例014、SqliteEZ_Bag\Assets\StoreWeapon.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class StoreWeapon:MonoBehaviour{
private WeaponBox box;
private HeroMessage msg;
void Start(){
box = GameObject.FindWithTag(“WeaponB”).GetComponent<WeaponBox>();
msg = GameObject.FindWithTag(“HeroMsg”).GetComponent<HeroMessage>();
}
//立钻哥哥：添加装备的按钮
//param equip:装备对象
public void OnAddEquipButtonClick(GameObject equip){
int index= box.CanAddEquip(); //查看装备栏中能否添加装备
//index != -1证明可以添加装备
if(index!= -1){
//拿到装备图片
Sprite equipImage = equip.GetComponent<Image>().sprite;
//将装备图片放置到装备栏中
box.transform.GetChild(index).GetComponent<Image>().sprite = equipImage;
string equipName = equip.name; //获取装备名称
//通过数据库查询到指定装备数据
DataBaseController.instance.ConnectToSqlite(“LOL”); //打开数据库
//查询并获得装备属性
float[] equipProperty = DataBaseController.instance.SelectHeroMsg(false,equipName);
//拿到人物属性
float[] heroProperty =DataBaseController.instance.SelectHeroMsg(true,“EZ”);
//生成新的人物属性
float[] newHeroProperty = DataBaseController.instance.AddOrRemoveProperty(true,heroProperty,equipProperty);
//将新的人物属性同步到数据库中
DataBaseController.instance.UpdateHeroProperty(newHeroProperty,“EZ”);
msg.UpdateUIMessage(newHeroProperty); //同步UI
DataBaseController.instance.closeSqliteConnection(); //关闭数据库
//将当前装备栏中的装备名称，存储到PlayerPrefs中
PlayerPrefs.SetString(“Weapon” +index,equip.name);
}
}
}
###WeaponBox.cs
（D:\yanlz_DemoPro()-\小案例014、SqliteEZ_Bag\Assets\WeaponBox.cs）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class WeaponBox:MonoBehaviour{
public Sprite defaultPicture; //装备栏的默认图片
private HeroMessage msg;
public Sprite[] equipPicture; //所有装备图片的数组
void Awake(){
msg = GameObject.FindWithTag(“HeroMsg”).GetComponent<HeroMessage>();
}
void Start(){
//获得两个Weapon
string weapon0 = PlayerPrefs.GetString(“Weapon0”);
stirng weapon1= PlayerPrefs.GetString(“Weapon1”);
if(weapon!=“Empty”){
//遍历图片库
foreach(Sprite item in equipPicture){
//如果图片库中的图片名称和PlayerPrefs的名称一样
if(item.name== weapon0){
//将图片库中的这张图片显示到装备栏中
transform.GetChild(0).GetComponent<Image>().sprete=item;
}
}
}
if(weapon1!= “Empty”){
//遍历图片库
foreach(Sprite item in equipPicture){
if(item.name == weapon1){
transform.GetChild(1).GetComponent<Image>().sprite=item;
}
}
}
}
//能否添加装备
public int CanAddEquip(){
//获取两个装备栏中的图片名称
string box01= transform.GetChild(0).GetComponent<Image>().sprite.name;
string box02 = transform.GetChild(1).GetComponent<Image>().sprite.name;
string defaultName =“InputFieldBackground”; //装备栏默认图片的名称
//如果装备栏中没有装备
if(box01 == defaultName){
return 0;
}else if(box02 == defaultName){
return 1;
}else{
return -1;
}
}
//移除装备按钮
//param equip:装备
public void OnRemoveEquipButtonClick(GameObject equip){
string defaultName= “InputFieldBackground”; //装备栏默认图片名
if(equip.GetComponent<Image>().sprite.name!=defaultName){
//获取当前装备栏的装备名称
string equipName =equip.GetComponent<Image>().sprite.name;
//将装备栏图片设置为默认图片
equip.GetComponent<Image>().sprite = defaultPicture;
DataBaseController.instance.ConnectToSqlite(“LOL”); //打开数据库
//查询数据库获取当前装备栏装备的属性
float[] equipProperty =DataBaseController.instance.SelectHeroMsg(false,equipName);
//人物的属性减去装备属性，获取新的属性，再去刷新UI
float[] heroProperty= DataBaseController.instance.SelectHeroMsg(true,“EZ”);
//得到一个新的属性
float[] newHeroProperty =DataBaseController.instance.AddOrRemoveProperty(false,heroProperty,equipProperty);
//更新属性
DataBaseController.instance.UpdateHeroProperty(newHeroProperty, “EZ”);
msg.UpdateUIMessage(newHeroProperty); //刷新UI
DataBaseController.instance.CloseSqliteConnection(); //关闭数据库
int index =0;
for(inti =0; i< transform.childCount; i++){
//如果该子对象就是自己本身
if(equip.transform == transform.GetChild(i)){
index =i; //获取位置
Debug.Log(equip.ToString() + “|” + transform.GetChild(i).ToString());
}
}
PlayerPrefs.SetString(“Weapon” +index,“Empty”);
}
}
}
#小案例015、Json数据存储
#小案例015、Json数据存储
++++CubeItem.cs
++++CubeManager.cs
++++CubeTest.cs
++++JsonDemo.cs
++++Person.cs
###CubeItem.cs
（D:\yanlz_DemoPro()-\小案例015、Json数据存储\Assets\Scripts\CubeItem.cs）
using UnityEngine;
using System.Collections;
public class CubeItem{
public string PosX{ get; set; };
public string PosY{ get; set; }
public string PosZ{ get; set; }
public CubeItem(){
}
public CubeItem(string x,stringy,string z){
this.PosX = x;
this.PosY = y;
this.PosZ = z;
}
public override string ToString(){
return string.Format(“X:” +PosX+“ Y:” +PosY+“ Z:” +PosZ);
}
}
###CubeManager.cs
（D:\yanlz_DemoPro()-\小案例015、Json数据存储\Assets\Scripts\CubeManager.cs）
using UnityEngine;
using System.Collections;
using LitJson;
using System.Collections.Generic;
using System;
using System.IO;
public class CubeManager:MonoBehaviour{
private Transform m_Transform; //父物体的Transform
private Transform[] allCubeTrans; //所有子物体的Transform
private List<CubeItem> cubeList; //Cube对象
private List<CubeItem> posList; //json数据里的对象
private string jsonPath= null;
private GameObject cubePrefab;
void Start(){
m_Transform = GetComponent<Transform>();
cubeList = new List<CubeItem>();
posList = new List<CubeItem>();
josnPath = Application.dataPath+“/Resources/json.txt”;
cubePrefab = Resources.Load<GameObject>(“Prefabs/Cube”);
}
void Update(){
if(Input.GetKeyDown(KeyCode.A)){
ObjectToJson();
}
if(Input.GetKeyDown(KeyCode.B)){
JsonToObject();
}
}
//立钻哥哥：对象转Json字符串数据
void ObjectToJson(){
cubeList.Clear();
allCubeTrans = m_Transform.GetComponentsInChildren<Transform>();
for(int i =1; i < allCubeTrans.Length; i++){
print(allCubeTrans[i].position);
Vector3 pos = allCubeTrans[i].position;
CubeItem item = new CubeItem(Math.Round(pos.x,2).ToString(),Math.Round(pos.y,2).ToString(),Math.Round(pos.z,2).ToString());
cubeList.Add(item);
}
string str =JsonMapper.ToJson(cubeList);
print(str);
//IO持久化json数据，把它以文本的形式存储在本地中
StreamWriter sw =new StreamWriter(josnPath);
sw.Write(str);
sw.Close();
}
//Json数据转对象
void JsonToObject(){
//读取json数据信息
TextAsset textAsset =Resource.Load<TextAsset>(“json”);
print(textAsset.text);
//把数据转化为对象
JsonData data =JsonMapper.ToObject(textAsset.text);
for(inti =0; i<data.Count; i++){
print(data[i].ToJson());
//指定对象接收数据
CubeItem item=JsonMapper.ToObject<CubeItem>(data[i].ToJson());
posList.Add(item);
}
for(inti =0; i<posList.Count; i++){
print(posList[i].ToString());
Vector3 pos=new Vector3(float.Parse(posList[i].PosX),float.Parse(posList[i].PosY),float.Parse(posList[i].PosZ));
GameObject.Instantiate(cubePrefab,pos,Quaternion.identity,m_Transform);
}
}
}
###CubeTest.cs
（D:\yanlz_DemoPro()-\小案例015、Json数据存储\Assets\Scripts\CubeTest.cs）
using UnityEngine;
using System.Collections;
using LitJson;
public class CubeTest:MonoBehaviour{
private Transform m_Transform;