devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity3D教学 开发简单版第一人称射击游戏 可以多人联机（附源码）_unity 多人联机 源码

作者：笔触狂放9 | 2024-02-18 03:03:33

赞

踩

unity 多人联机 源码

简介：

这一篇文章主要是和大家分享如何制作一个属于自己的“第一人称射击游戏”，而且是要可以多人联机的。这个游戏属于比简单的，大神可以直接无视，如果有做错的地方请大家多多指点，我也是刚学如何做游戏。代码是用C#编写，主要实现的功能有三个：第一人称移动控制、角色控制（如射击）、TCP服务端和客户端。我将项目命名为FPS。


游戏运作流程：

服务端

1. 创建服务端

2. 从各个客户端接收数据，然后广播给所有客户


客户端

1. 连接至服务端

2. 从服务端接收到其他客户的数据（比如当前位置，是否有开枪等等），然后更新到游戏上

3. 发送自己当前在游戏的状态给服务端


联机效果图：

服务端



客户端



完整源代码与已编译好的游戏程序:

下载


C#脚本简介:

1. FirstPersonControl.cs

这个脚本是用来做第一人称控制的

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class FirstPersonControl : MonoBehaviour {
  6.  
  7. 	// Use this for initialization
  8. 	void Start () {
  9.         // 获取摄像头对象
  10.         mCamera = transform.Find("Main Camera");
  11.         // 获取右手对象
  12.         mRightHand = transform.Find("RightHand");
  13.         // 获取脚步声播放组建
  14.         mAudio = transform.GetComponent<AudioSource>();
  15. 	}
  16.  
  17.     // Update is called once per frame
  18.     void Update() {
  19.         if (UpdateMovement()) {
  20.             PlayStepSound();
  21.         } else {
  22.             StopPlayStepSound();
  23.         }
  24.  
  25.         UpdateLookAt();
  26.     }
  27.  
  28.     // 第一人称控制器的常量与变量
  29.     private Transform mCamera;
  30.     private Transform mRightHand;
  31.     private AudioSource mAudio;
  32.     public float mMoveSpeed = 8;         // 物体移动速度
  33.     public float mMouseSensitivity = 5;     // 鼠标旋转的敏感度
  34.     public float mMinimumX = 325;       // 向下望的最大角度
  35.     public float mMaximumX = 45;        // 向上望的最大角度
  36.     public float mMinimumY = -360;         // 向左望的最大角度
  37.     public float mMaximumY = 360;       // 向右望的最大角度
  38.     private Vector3 _curRotation = new Vector3(0,0,0);       // 当前旋转角度
  39.  
  40.     // 更新移动位置
  41.     private bool UpdateMovement() {
  42.         float distance = mMoveSpeed * Time.deltaTime;   // 移动距离
  43.         
  44.         // 前
  45.         if (Input.GetKey(KeyCode.W)) {
  46.             float x = Mathf.Sin(transform.eulerAngles.y * Mathf.Deg2Rad) * distance;
  47.             float z = Mathf.Cos(transform.eulerAngles.y * Mathf.Deg2Rad) * distance;
  48.             transform.Translate(new Vector3(x,0,z), Space.World);
  49.             return true;
  50.         }
  51.  
  52.         // 后
  53.         if (Input.GetKey(KeyCode.S)) {
  54.             float x = Mathf.Sin(transform.eulerAngles.y * Mathf.Deg2Rad) * distance;
  55.             float z = Mathf.Cos(transform.eulerAngles.y * Mathf.Deg2Rad) * distance;
  56.             transform.Translate(new Vector3(-x, 0, -z), Space.World);
  57.             return true;
  58.         }
  59.  
  60.         // 左
  61.         if (Input.GetKey(KeyCode.A)) {
  62.             transform.Translate(new Vector3(-distance, 0, 0));
  63.             return true;
  64.         }
  65.  
  66.         // 右
  67.         if (Input.GetKey(KeyCode.D)) {
  68.             transform.Translate(new Vector3(distance, 0, 0));
  69.             return true;
  70.         }
  71.  
  72.         return false;
  73.     }
  74.  
  75.     // 更新摄像头指向位置
  76.     private void UpdateLookAt() {
  77.         // 左右旋转
  78.         _curRotation.y = _curRotation.y + Input.GetAxis("Mouse X") * mMouseSensitivity;
  79.         _curRotation.y = Mathf.Clamp(_curRotation.y, mMinimumY, mMaximumY);
  80.  
  81.         // 设置身体
  82.         Vector3 rotation = transform.eulerAngles;
  83.         rotation.y = _curRotation.y;
  84.         transform.eulerAngles = rotation;
  85.  
  86.         // 上下旋转
  87.         _curRotation.x = _curRotation.x  - Input.GetAxis("Mouse Y") * mMouseSensitivity;
  88.         _curRotation.x = Mathf.Clamp(_curRotation.x, mMinimumX, mMaximumX);
  89.  
  90.         // 设置摄像头
  91.         mCamera.localEulerAngles = new Vector3(_curRotation.x, 0, 0);
  92.  
  93.         // 设置右手
  94.         rotation = mRightHand.eulerAngles;
  95.         rotation.x = _curRotation.x;
  96.         mRightHand.eulerAngles = rotation;
  97.     }
  98.  
  99.     // 播放脚步声
  100.     private void PlayStepSound() {
  101.         if (!mAudio.isPlaying) {
  102.             mAudio.Play();
  103.         }
  104.     }
  105.  
  106.     // 停止播放声音
  107.     private void StopPlayStepSound() {
  108.         if (mAudio.isPlaying) {
  109.             mAudio.Stop();
  110.         }
  111.     }
  112. }


2. Character.cs

角色控制脚本，主要是用来控制开枪等角色动作

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Character : MonoBehaviour {
  6.  
  7.     // Use this for initialization
  8.     void Start() {
  9.         // 获取摄像头对象
  10.         mCamera = transform.Find("Main Camera");
  11.         // 获取右手对象
  12.         mRightHand = transform.Find("RightHand");
  13.         // 获取枪声播放组件
  14.         mGunAudio = transform.Find("RightHand/Pistol").GetComponent<AudioSource>();
  15.         // 获取火花效果
  16.         mFireEffect = transform.Find("RightHand/Pistol/FireEffect").GetComponent<ParticleSystem>();
  17.         // 获取网络组件
  18.         mNetwork = transform.GetComponent<Network>();
  19.     }
  20.  
  21.     // Update is called once per frame
  22.     void Update() {
  23.         UpdateFire();
  24.  
  25.         // 发送当前状态到服务端，然后服务端就会转发给其他客户
  26.         mNetwork.SendStatus(transform.position, transform.eulerAngles, 
  27.         mCamera.eulerAngles, mRightHand.eulerAngles, _isShooted, _hp);
  28.  
  29.         // 处理服务器发过来的数据包，数据包里装着其他客户的信息
  30.         ProcessPackage();
  31.     }
  32.  
  33.     private Transform mCamera;
  34.     private Transform mRightHand;
  35.     private AudioSource mGunAudio;
  36.     public GameObject mPiece;       // 开枪后撞击产生的碎片
  37.     private ParticleSystem mFireEffect;     // 开枪后的火花
  38.     private bool _isShooted;    // 判断是否开了枪
  39.     private Network mNetwork;       // 网络组件
  40.     public GameObject mEnemyCharacter;  // 其他客户的实例
  41.     private Hashtable _htEnemies = new Hashtable();    // 其他客户的控制脚本
  42.  
  43.     // 开枪
  44.     private void UpdateFire() {
  45.         if (Input.GetButtonUp("Fire1")) {
  46.             // 射击音效与画面
  47.             PlayShotSound();
  48.  
  49.             // 播放火花效果
  50.             PlayFireEffect();
  51.  
  52.             // 判断射击位置
  53.             RaycastHit hit;
  54.             if (Physics.Raycast(mCamera.position, mCamera.forward, out hit, 100)) {
  55.                 // 被枪击中的地方会有碎片弹出
  56.                 DrawPieces(hit);
  57.             }
  58.  
  59.             // 设置开枪判断
  60.             _isShooted = true;
  61.         } else {
  62.             // 设置开枪判断
  63.             _isShooted = false;
  64.         }
  65.     }
  66.  
  67.     // 播放枪声
  68.     private void PlayShotSound() {
  69.         mGunAudio.PlayOneShot(mGunAudio.clip);
  70.     }
  71.  
  72.     // 画碎片
  73.     private void DrawPieces(RaycastHit hit) {
  74.         for (int i = 0; i < 5; ++i) {
  75.             GameObject p = Transform.Instantiate(mPiece);
  76.  
  77.             // 碎片撞击到物体后的反弹位置
  78.             Vector3 fwd = mCamera.forward * -1;
  79.             p.transform.position = hit.point;
  80.             p.GetComponent<Rigidbody>().AddForce(fwd * 100);
  81.  
  82.             // 0.3秒后删除
  83.             Destroy(p, 0.3f);
  84.         }
  85.     }
  86.  
  87.     // 播放火花效果
  88.     private void PlayFireEffect() {
  89.         mFireEffect.Play();
  90.     }
  91.  
  92.     // 人物变量
  93.     private int _hp = 100;
  94.  
  95.     // 受到伤害
  96.     public void GetHurt() {
  97.         _hp -= 10;
  98.  
  99.         if (_hp <= 0) {
  100.             // 复活
  101.             Revive();
  102.         }
  103.     }
  104.  
  105.     // 复活
  106.     private void Revive() {
  107.         _hp = 100;
  108.         transform.position = new Vector3(0,1,0);
  109.     }
  110.  
  111.     // 处理数据包
  112.     private void ProcessPackage() {
  113.         Network.Package p;
  114.  
  115.         // 获取数据包直到完毕
  116.         while (mNetwork.NextPackage(out p)) {
  117.             // 确定不是本机，避免重复
  118.             if (mNetwork._id == p.id) {
  119.                 return;
  120.             }
  121.  
  122.             // 获取该客户相对应的人物模组
  123.             if (!_htEnemies.Contains(p.id)) {
  124.                 AddEnemyCharacter(p.id);
  125.             }
  126.  
  127.             // 更新客户的人物模型状态
  128.             EnemyCharacter ec = (EnemyCharacter)_htEnemies[p.id];
  129.  
  130.             // 血量
  131.             ec.SetHP(p.hp);
  132.  
  133.             // 移动动作
  134.             ec.Move(p.pos.V3, p.rot.V3, p.cameraRot.V3, p.rightHandRot.V3);
  135.  
  136.             // 开枪
  137.             if (p.isShooted) {
  138.                 ec.Fire();
  139.             }
  140.         }
  141.     }
  142.  
  143.     // 增加客户的人物模组
  144.     private EnemyCharacter AddEnemyCharacter(int id) {
  145.         GameObject p = GameObject.Instantiate(mEnemyCharacter);
  146.         EnemyCharacter ec = p.GetComponent<EnemyCharacter>();
  147.         
  148.         // 修改ID
  149.         ec.SetID(id);
  150.  
  151.         // 加入到哈希表
  152.         _htEnemies.Add(id, ec);
  153.  
  154.         return ec;
  155.     }
  156.  
  157.     // 删除客户的人物模组
  158.     private void RemoveEnemyCharacter(int id) {
  159.         EnemyCharacter ec = (EnemyCharacter)_htEnemies[id];
  160.         ec.Destroy();
  161.         _htEnemies.Remove(id);
  162.     }
  163.  
  164.     // 删除所有客户的人物模组
  165.     public void RemoveAllEnemyCharacter() {
  166.         foreach (int id in _htEnemies.Keys) {
  167.             EnemyCharacter ec = (EnemyCharacter)_htEnemies[id];
  168.             ec.Destroy();
  169.         }
  170.         _htEnemies.Clear();
  171.     }
  172. }


3.Network.cs

网络组件，用来创建服务端或客户端。服务端负责广播从各个客户端接收的数据给所有客户。客户端则是接收从服务端接收其他客户的数据。

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using System;
  5. using System.IO;
  6. using System.Runtime.Serialization.Formatters.Binary;
  7. using System.Net;
  8. using System.Net.Sockets;
  9.  
  10. public class Network : MonoBehaviour {
  11.  
  12. 	// Use this for initialization
  13. 	void Start () {
  14.         // 获取人物组件
  15.         mCharacter = transform.GetComponent<Character>();
  16.         // 数据包大小
  17.         _packageSize = PackageSize(); 
  18. 	}
  19. 	
  20. 	// Update is called once per frame
  21. 	void Update () {
  22.  
  23. 	}
  24.  
  25.     // 网络设置UI
  26.     void OnGUI() {
  27. 		GUI.Box (new Rect(0,0,800,60),"网络设置");
  28.  
  29.         if (_connected) {
  30. 		    GUI.Label (new Rect(10,25,100,25), _isServer ? "已建立服务端":"已连接服务端");
  31.         } else if (!_connected) {
  32. 		    GUI.Label (new Rect(10,25,100,25), "未连接");
  33.         }
  34.  
  35. 		GUI.Label (new Rect(130,25,20,25), "IP:");
  36.         GUI.Label (new Rect(270,25,40,25), "端口:");
  37.         GUI.Label (new Rect(380,25,40,25), "ID:");
  38.  
  39. 		if (!_connected && !_isServer) {
  40. 			_ip = GUI.TextField (new Rect (150, 25, 100, 25), _ip, 100);
  41.             _port = System.Convert.ToInt32 (GUI.TextField (new Rect (310, 25, 50, 25), _port.ToString (), 100));
  42.             _id = System.Convert.ToInt32 (GUI.TextField (new Rect (420, 25, 100, 25), _id.ToString(), 100));
  43. 		} else {
  44. 			GUI.TextField (new Rect (150, 25, 100, 25), _ip, 100);
  45.             GUI.TextField (new Rect (310, 25, 50, 25), _port.ToString (), 100);
  46.             GUI.TextField (new Rect (420, 25, 100, 25), _id.ToString(), 100);
  47.         }
  48.  
  49.         if (!_connected && !_isServer) {
  50.             if (GUI.Button(new Rect(540,25,100,25), "开启服务端")) {
  51.                 StartServer();
  52.                 ConnectServer();
  53.             }
  54.  
  55.             if (GUI.Button(new Rect(660,25,100,25), "连接至服务端")) {
  56.                 ConnectServer();
  57.             }
  58.         } else {
  59.             if (_isServer) {
  60.                 if (GUI.Button(new Rect(540,25,100,25), "关闭服务端")) {
  61.                     StopServer();
  62.                 }
  63.             } else if (_connected) {
  64.                 if (GUI.Button(new Rect(540,25,100,25), "取消连接")) {
  65.                     DisconnectServer();
  66.                 }
  67.             }
  68.         }
  69. 	}
  70.  
  71.     // 服务端和客户端的共有变量
  72.     private Character mCharacter; // 人物组件
  73.     private bool _connected=false;  // 判断是否已经建立连接或开启服务端
  74.     private bool _isServer=false;   // 判断本程序建立的是服务端还是客户端
  75.     private string _ip = "127.0.0.1";           // 主机IP
  76.     private int _port = 18000;             // 端口
  77.     public int _id = 1 ;           // 人物id
  78.     List<Package> _packages=new List<Package>();        // 数据包
  79.     private int _packageSize;        // 数据包大小
  80.  
  81.     // 数据包
  82.     [Serializable]
  83.     public struct Package {
  84.         public int id;
  85.         public Vector3Serializer pos;   // 人物位置
  86.         public Vector3Serializer rot;   // 人物旋转角度
  87.         public Vector3Serializer cameraRot;     // 摄像头旋转角度
  88.         public Vector3Serializer rightHandRot;  // 右手旋转角度
  89.         public bool isShooted;      // 判断是否有开枪
  90.         public int hp;      // 血量
  91.     }
  92.  
  93.     // 获取包大小
  94.     private int PackageSize() {
  95.         Package p = new Package();
  96.         byte[] b;
  97.         Serialize(p, out b);
  98.         return b.Length;
  99.     }
  100.  
  101.     // 可序列化的Vector3
  102.     [Serializable]
  103. 	public struct Vector3Serializer {
  104. 		public float x;
  105. 		public float y;
  106. 		public float z;
  107.  
  108. 		public void Fill(Vector3 v3) {
  109. 			x = v3.x;
  110. 			y = v3.y;
  111. 			z = v3.z;
  112. 		}
  113.  
  114. 		public Vector3 V3
  115. 		{ get { return new Vector3(x, y, z); } }
  116. 	}
  117.  
  118.     // 序列化数据包
  119.     public bool Serialize(object obj, out byte[] result) {
  120.         bool ret = false;
  121.         result = null;
  122.  
  123.         try {
  124.             MemoryStream ms = new MemoryStream();
  125.             BinaryFormatter bf = new BinaryFormatter();
  126.             bf.Serialize(ms, obj);
  127.             result = ms.ToArray(); 
  128.         
  129.             ret = true;
  130.         } catch (Exception e) {
  131.             ret = false;
  132.             Debug.Log(e.Message);
  133.         }
  134.  
  135.         return ret;
  136.     }
  137.  
  138.     // 反序列化数据包
  139.     public bool Deserialize(byte[] data,out object result) {
  140.         bool ret = false;
  141.         result = new object();
  142.  
  143.         try {
  144.             MemoryStream ms = new MemoryStream(data);
  145.             BinaryFormatter bf = new BinaryFormatter();
  146.             result = bf.Deserialize(ms);
  147.         
  148.             ret = true;
  149.         } catch (Exception e) {
  150.             ret = false;
  151.             Debug.Log(e.Message);
  152.         }
  153.  
  154.         return ret;
  155.     }
  156.  
  157.     // 服务端变量
  158.     TcpListener _listener;
  159.     
  160.     // 储存已连接客户的结构体
  161.     private struct Client {
  162.         public TcpClient client;
  163.         public byte[] buffer;               // 接收缓冲区
  164.         public List<byte> pendingData;    // 还未处理的数据
  165.     }
  166.  
  167.     // 客户列表
  168.     List<Client> _clients = new List<Client>();
  169.  
  170.     // 开启服务端
  171.     private void StartServer() {
  172.         try {
  173.             _listener = new TcpListener(IPAddress.Any, _port);
  174.             _listener.Start();
  175.             _listener.BeginAcceptSocket(HandleAccepted, _listener);
  176.  
  177.             _isServer = true;
  178.         } catch (Exception e) {
  179.             Debug.Log(e.Message);
  180.         }
  181.     }
  182.  
  183.     // 停止停止服务端
  184.     private void StopServer() {
  185.         try {
  186.             _listener.Stop();
  187.  
  188.             // 清空客户列表
  189.             lock (_clients) {
  190.                 foreach (Client c in _clients) {
  191.                     RemoveClient(c);
  192.                 }
  193.                 _clients.Clear();
  194.             }
  195.  
  196.             // 清空数据包
  197.             lock (_packages) {
  198.                 _packages.Clear();
  199.             }
  200.             
  201.             _isServer = false;
  202.         } catch (Exception e) {
  203.             Debug.Log(e.Message);
  204.         }
  205.     }
  206.  
  207.     // 处理客户端连接的回调函数
  208.     private void HandleAccepted(IAsyncResult iar) {
  209.         if (_isServer) {
  210.             TcpClient tcpClient = _listener.EndAcceptTcpClient(iar);
  211.             Client client = new Client();
  212.             client.client = tcpClient;
  213.             client.buffer = new byte[tcpClient.ReceiveBufferSize];
  214.             client.pendingData = new List<byte>();
  215.  
  216.             // 把客户加入到客户列表
  217.             lock (_clients) {
  218.                 AddClient(client);
  219.             }
  220.  
  221.             // 开始异步接收从客户端收到的数据
  222.             tcpClient.GetStream().BeginRead(
  223.                     client.buffer,
  224.                     0,
  225.                     client.buffer.Length,
  226.                     HandleClientDataReceived,
  227.                     client);
  228.  
  229.             // 开始异步接收连接
  230.             _listener.BeginAcceptSocket(HandleAccepted, _listener);
  231.         }
  232.     }
  233.  
  234.     // 从客户端接收数据的回调函数
  235.     private void HandleClientDataReceived(IAsyncResult iar) {
  236.         try {
  237.             if (_isServer) {
  238.                 Client client = (Client)iar.AsyncState;
  239.                 NetworkStream ns = client.client.GetStream();
  240.                 int bytesRead = ns.EndRead(iar);
  241.  
  242.                 // 连接中断
  243.                 if (bytesRead == 0) {
  244.                     lock (_clients) {
  245.                         _clients.Remove(client);
  246.                     }
  247.                     return;
  248.                 }
  249.  
  250.                 // 保存数据
  251.                 for (int i=0; i<bytesRead; ++i) {
  252.                     client.pendingData.Add(client.buffer[i]);
  253.                 }
  254.  
  255.                 // 把数据解析成包
  256.                 while (client.pendingData.Count >= _packageSize) {
  257.                     byte[] bp = client.pendingData.GetRange(0, _packageSize).ToArray();
  258.                     client.pendingData.RemoveRange(0, _packageSize);
  259.  
  260.                     // 把数据包分发给所有客户
  261.                     lock(_clients) {
  262.                         foreach (Client c in _clients) {
  263.                             c.client.GetStream().Write(bp, 0, _packageSize);
  264.                             c.client.GetStream().Flush();
  265.                         }
  266.                     }
  267.                 }
  268.  
  269.                 // 开始异步接收从客户端收到的数据
  270.                 client.client.GetStream().BeginRead(
  271.                         client.buffer,
  272.                         0,
  273.                         client.buffer.Length,
  274.                         HandleClientDataReceived,
  275.                         client);
  276.             }
  277.         } catch (Exception e) {
  278.             Debug.Log(e.Message);
  279.         }
  280.     }
  281.  
  282.     // 加入客户
  283.     private void AddClient(Client c) {
  284.         _clients.Add(c);
  285.     }
  286.  
  287.     // 删除客户
  288.     private void RemoveClient(Client c) {
  289.         c.client.Client.Disconnect(false);
  290.     }
  291.  
  292.     // 客户端变量
  293.     Client _server;
  294.  
  295.     // 连接至服务端
  296.     private void ConnectServer() {
  297.         try {
  298.             TcpClient tcpServer = new TcpClient();
  299.             tcpServer.Connect(_ip, _port);
  300.             _server = new Client();
  301.             _server.client = tcpServer;
  302.             _server.buffer = new byte[tcpServer.ReceiveBufferSize];
  303.             _server.pendingData = new List<byte>();
  304.             
  305.             // 异步接收服务端数据
  306.             tcpServer.GetStream().BeginRead(
  307.                 _server.buffer, 
  308.                 0, 
  309.                 tcpServer.ReceiveBufferSize,
  310.                 HandleServerDataReceived,
  311.                 _server);
  312.  
  313.             _connected = true;
  314.         } catch (Exception e) {
  315.             Debug.Log(e.Message);
  316.         }
  317.     }
  318.  
  319.     // 从服务端断开
  320.     private void DisconnectServer() {
  321.         try {
  322.             lock (_server.client) {
  323.                 _server.client.Client.Close();
  324.             }
  325.  
  326.             // 清空数据包
  327.             lock (_packages) {
  328.                 _packages.Clear();
  329.             }
  330.  
  331.             // 删除所有客户人物模型
  332.             mCharacter.RemoveAllEnemyCharacter();
  333.  
  334.             _connected = false;
  335.         } catch (Exception e) {
  336.             Debug.Log(e.Message);
  337.         }
  338.     }
  339.  
  340.     // 从服务端读取数据的回调函数
  341.     private void HandleServerDataReceived(IAsyncResult iar) {
  342.         if (_connected) {
  343.             Client server = (Client)iar.AsyncState;
  344.             NetworkStream ns = server.client.GetStream();
  345.             int bytesRead = ns.EndRead(iar);
  346.       
  347.             // 连接中断
  348.             if (bytesRead == 0) {
  349.                 DisconnectServer();
  350.                 return;
  351.             }
  352.  
  353.             // 保存数据
  354.             for (int i=0; i<bytesRead; ++i) {
  355.                 server.pendingData.Add(server.buffer[i]);
  356.             }
  357.  
  358.             // 把数据解析成包
  359.             while (server.pendingData.Count >= _packageSize) {
  360.                 byte[] bp = server.pendingData.GetRange(0, _packageSize).ToArray();
  361.                 server.pendingData.RemoveRange(0,_packageSize);
  362.  
  363.                 // 把数据转换成包然后再储存包列表
  364.                 object obj;
  365.                 Deserialize(bp, out obj);
  366.  
  367.                 lock (_packages) {
  368.                     _packages.Add((Package)obj);
  369.                 }
  370.             }
  371.  
  372.             // 异步接收服务端数据
  373.             server.client.GetStream().BeginRead(
  374.                 server.buffer, 
  375.                 0, 
  376.                 server.client.ReceiveBufferSize,
  377.                 HandleServerDataReceived,
  378.                 server);
  379.         }
  380.     }
  381.     
  382.     // 发送自己的当前的状态包给服务端
  383.     public void SendStatus(Vector3 pos, Vector3 rot,Vector3 cameraRot, 
  384.         Vector3 rightHandRot, bool isShooted, int hp) {
  385.         try {
  386.             if (_connected) {     
  387.                 Package p = new Package();
  388.                 p.id = _id;
  389.                 p.pos.Fill(pos);
  390.                 p.rot.Fill(rot);
  391.                 p.cameraRot.Fill(cameraRot);
  392.                 p.rightHandRot.Fill(rightHandRot);
  393.                 p.isShooted = isShooted;
  394.                 p.hp = hp;
  395.  
  396.                 // 发送包到服务端
  397.                 byte[] bp;
  398.                 Serialize(p, out bp);
  399.  
  400.                 lock (_server.client) {
  401.                     _server.client.GetStream().Write(bp, 0, _packageSize);
  402.                     _server.client.GetStream().Flush();
  403.                 }
  404.             }
  405.         } catch (Exception e) {
  406.             Debug.Log(e.Message);
  407.  
  408.             // 断开服务端
  409.             DisconnectServer();
  410.         }
  411.     }
  412.  
  413.     // 获取包
  414.     public bool NextPackage(out Package p) {
  415.         lock (_packages) {
  416.             if (_packages.Count == 0) {
  417.                 p = new Package();
  418.                 return false;
  419.             }
  420.  
  421.             p = _packages[0];
  422.             _packages.RemoveAt(0);
  423.         }
  424.  
  425.         return true;
  426.     }
  427. }

4.EnemyCharacter.cs

这个脚本负责控制其他客户的行为，比如从服务端接收到其他客户移动或开枪的数据，就要用这个脚本来更新其他客户的当前行为

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class EnemyCharacter : MonoBehaviour {
  6.  
  7. 	// Use this for initialization
  8. 	void Start () {
  9.         // 获取本机玩家的对象
  10.         mCharacter = GameObject.Find("Character").transform;
  11.         mCharacterComponent = mCharacter.GetComponent<Character>();
  12.         // 获取摄像头对象
  13.         mCamera = transform.Find("Camera");
  14. 		// 获取右手对象
  15.         mRightHand = transform.Find("RightHand");
  16.         // 获取枪声播放组件
  17.         mGunAudio = transform.Find("RightHand/Pistol").GetComponent<AudioSource>();
  18.         // 获取火花效果
  19.         mFireEffect = transform.Find("RightHand/Pistol/FireEffect").GetComponent<ParticleSystem>();
  20.         // 获取脚步声播放组件
  21.         mAudio = transform.GetComponent<AudioSource>();
  22.         // 显示血量和ID的组件
  23.         txID = transform.Find ("ID");
  24.         txIDText = transform.Find ("ID").GetComponent<TextMesh> ();
  25.         txHP = transform.Find ("HP");
  26. 		txHPText = transform.Find ("HP").GetComponent<TextMesh> ();
  27. 	}
  28. 	
  29. 	// Update is called once per frame
  30. 	void Update () {
  31. 		// 摧毁对象
  32.         if (isDestroy) {
  33.             Destroy(gameObject);
  34.         }
  35.  
  36.         // 更新对象属性
  37.         UpdataProperties();
  38. 	}
  39.     
  40.     private Transform mCharacter;
  41.     private Character mCharacterComponent;
  42.     private Transform mCamera;
  43.     private Transform mRightHand;
  44.     private AudioSource mGunAudio;
  45.     private AudioSource mAudio;
  46.     private ParticleSystem mFireEffect;     // 开枪后的火花
  47.     public GameObject mPiece;       // 开枪后撞击产生的碎片
  48.     private bool isDestroy = false;
  49.  
  50.     // 销毁角色
  51.     public void Destroy() {
  52.         isDestroy = true;
  53.     }
  54.  
  55.     // 角色移动动作
  56.     public void Move(Vector3 pos, Vector3 rot, Vector3 cameraRot, Vector3 rightHandRot) {
  57.         if (pos != transform.position) {
  58.             transform.position = pos;
  59.             PlayStepSound();
  60.         } else {
  61.             StopPlayStepSound();
  62.         }
  63.  
  64.         mCamera.eulerAngles = cameraRot;
  65.  
  66.         transform.eulerAngles = rot;
  67.  
  68.         mRightHand.eulerAngles = rightHandRot;
  69.     }
  70.  
  71.     // 播放脚步声
  72.     private void PlayStepSound() {
  73.         if (!mAudio.isPlaying) {
  74.             mAudio.Play();
  75.         }
  76.     }
  77.  
  78.     // 停止播放声音
  79.     private void StopPlayStepSound() {
  80.         if (mAudio.isPlaying) {
  81.             mAudio.Stop();
  82.         }
  83.     }
  84.  
  85.     // 开枪
  86.     public void Fire() {
  87.         // 射击音效与画面
  88.         PlayShotSound();
  89.  
  90.         // 播放火花效果
  91.         PlayFireEffect();
  92.  
  93.         // 判断射击位置
  94.         RaycastHit hit;
  95.         if (Physics.Raycast(mCamera.position, mCamera.forward, out hit, 100)) {
  96.             // 被枪击中的地方会有碎片弹出
  97.             DrawPieces(hit);
  98.  
  99.             // 判断本机玩家是否中枪如果是就减
  100.             print(hit.collider.name);
  101.             if (hit.collider.name == mCharacter.name) {
  102.                 mCharacterComponent.GetHurt();
  103.             }
  104.         }
  105.     } 
  106.  
  107.     // 播放枪声
  108.     private void PlayShotSound() {
  109.         mGunAudio.PlayOneShot(mGunAudio.clip);
  110.     }
  111.  
  112.     // 画碎片
  113.     private void DrawPieces(RaycastHit hit) {
  114.         for (int i = 0; i < 5; ++i) {
  115.             GameObject p = Transform.Instantiate(mPiece);
  116.  
  117.             // 碎片撞击到物体后的反弹位置
  118.             Vector3 fwd = mCamera.forward * -1;
  119.             p.transform.position = hit.point;
  120.             p.GetComponent<Rigidbody>().AddForce(fwd * 100);
  121.  
  122.             // 0.3秒后删除
  123.             Destroy(p, 0.3f);
  124.         }
  125.     }
  126.  
  127.     // 播放火花效果
  128.     private void PlayFireEffect() {
  129.         mFireEffect.Play();
  130.     }
  131.  
  132.     // 人物变量
  133.     private int _id = 1;
  134.     private int _hp = 100;
  135.     private Transform txID;
  136.     private TextMesh txIDText;
  137.     private Transform txHP;
  138.     private TextMesh txHPText;
  139.  
  140.     // 角色id
  141.     public void SetID(int id) {
  142.         _id = id;
  143.     }
  144.  
  145.     // 角色血量
  146.     public void SetHP(int hp) {
  147.         _hp = hp;
  148.     }
  149.  
  150.     // 更新角色变量/属性
  151.     private void UpdataProperties() {
  152.         // 显示血量和ID
  153.         txIDText.text = "ID:"+_id.ToString();
  154.         txHPText.text = "HP:"+_hp.ToString();
  155.  
  156.         // 血量和ID的方向，面向着本机玩家
  157.         txID.rotation = mCharacter.rotation;
  158.         txHP.rotation = mCharacter.rotation;
  159.     }
  160. }


声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/104073
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号