Unity3D-网络（一）高级开发-网络解决方案

  public virtual void OnServerAddPlayer(NetworkConnection conn, short playerControllerId)
    {
       var player = (GameObject)GameObject.Instantiate(playerPrefab, playerSpawnPos, Quaternion.identity);
      NetworkServer.AddPlayerForConnection(conn, player, playerControllerId);
    }

using UnityEngine;
using System.Collections;
using UnityEngine.Networking;

public class Player_NetworkStep : NetworkBehaviour {

    public Camera firstControllerCamera;
    public AudioListener lister;
    void Start () {
        if (isLocalPlayer) // 判断是否是本地游戏对象
        {
            GameObject.FindWithTag("MainCamera").SetActive(false);
            GetComponent<CharacterController>().enabled = true;
            GetComponent<UnityStandardAssets.Characters.FirstPerson.FirstPersonController>().enabled = true;
            firstControllerCamera.enabled = true;
            lister.enabled = true;
        }
    }   
}

using UnityEngine;
using System.Collections;
using UnityEngine.Networking;

// 必须继承NetWorkBehaviour
public class Player_NetworkStep : NetworkBehaviour {
    [SyncVar] // 用来标记同步成员变量，可以是任何基本数据类型，但不能是类、列表或其他集合
    Vector3 synsPos;
    public Transform myTransform;
    public float lerpRate = 15;

    void FixedUpdate()
    {
        TransmitPosition();
        LerpPosition();
    }

    void LerpPosition()
    {
        if (!isLocalPlayer)
        {
            myTransform.position = Vector3.Lerp(myTransform.position, synsPos, Time.deltaTime);
        }
    }
    [Command] // 新的网络系统中的RPC,即在客户端调用，在服务器执行。还有一种是ClientRpcCalls,正好相反
    void CmdProvidePositionToServer(Vector3 pos) // 方法以Cmd开头，使用此命令的任意参数都会被传递到服务器端
    {
        synsPos = pos;
    }

    [ClientCallback] // 可作为成员函数的自定义属性
    void TransmitPosition()
    {
        if (isLocalPlayer)
        {
            CmdProvidePositionToServer(myTransform.position);
        }
    }

[Command(channel=1)]

    [Client] // 只作用在客户端
    [Server] // 只作用在服务器端
    [ClientCallback] // engine调用函数，只在客户端执行

using UnityEngine;
using System.Collections;
using UnityEngine.Networking;
using System;

public class Player_syncRotation : NetworkBehaviour {

    [SyncVar]
    private Quaternion syncPlayerRotion;
    [SyncVar]
    private Quaternion syncCamRotation;
    [SerializeField]
    private Transform playerTrans;
    private Transform camTransform;
    private float lerpRate = 15;


    void FixedUpdate()
    {
        TransmitRotation();
        LerpRotation();
    }

    private void TransmitRotation()
    {
      
    }

    private void LerpRotation()
    {
        if (!isLocalPlayer)
        {
            playerTrans.rotation = Quaternion.Lerp(playerTrans.rotation, syncPlayerRotion, Time.deltaTime * lerpRate);
            camTransform.rotation = Quaternion.Lerp(camTransform.rotation, syncCamRotation, Time.deltaTime * lerpRate);
        }
    }
    [Command]
    void CmdProvideRotationToServer(Quaternion playerRot, Quaternion cameRot)
    {
        syncPlayerRotion = playerRot;
        syncCamRotation = cameRot;
    }
    [Client]
    void TransmitRotion()
    {
        if (isLocalPlayer)
        {
            CmdProvideRotationToServer(playerTrans.rotation, camTransform.rotation);
        }
    }
}

// 添加他的网络通道与网络通信间歇
[NetworkSettings(channel = 0, sendInterval = 0.033f)]
public class Player_syncRotation : NetworkBehaviour 

        // 不带参数初始化
        NetworkTransport.Init();
        // 设置最大数据包为500
        GlobalConfig globalconfig = new GlobalConfig();
        globalconfig.MaxPacketSize = 500;
        NetworkTransport.Init(globalconfig);

        ConnectionConfig config = new ConnectionConfig();
        // QosType.Reliable 可靠连接，确保信息传输安全
        byte reliableByteId = config.AddChannel(QosType.Reliable);
        // QosType.Unreliable 不可靠连接，传输速度快，不能保证信息传递
        byte unreliableByteId = config.AddChannel(QosType.Unreliable);
        // 网络拓扑的定义， （连接使用配置信息，允许连接数）
        HostTopology topology = new HostTopology(config, 10);

       // 创建主机服务(端口号：8888)
        int intHostID = NetworkTransport.AddHost(topology, 8888);

    private byte error;
    private byte[] buffer;
    private int bufferLength = 1024;

        // 先将不同的命令发送主机并检查状态
        // 返回一个给此链接的ID
        int connetionID = NetworkTransport.Connect(intHostID, "192.168.1.131", 8888, 0, out error);
        // 此命令发送断开链接的请求
        NetworkTransport.Disconnect(intHostID, connetionID, out error);
        // 发送信息，将消息存储在缓存区消息长度为bufferLength
        NetworkTransport.Send(intHostID, connetionID, reliableByteId, buffer, bufferLength, out error);

// 检测主机状态：
void Update () {
        myConnectinID = NetworkTransport.Connect(hostId, "192.168.1.133", 8888, 0, out error);
        // 此函数返回来自任意主机的事件（recHostId返回主机ID）
        NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionID, out reliableByteId, recbuffer, bufferSize, out dataSize, out error);
         switch(recData)
         {
            case NetworkEventType.ConnectEvent:
                if (myConnectinID == connetionID)
                {
                    // 主动连接请求成功
                }
                else {
                    // 其他人连接到我
                }
                
                break;
        }
 // 此函数为检测主机ID
 // NetworkTransport.ReceiveRelayEventFromHost

}   

// ip为监听地址，为null，将监听所有的网路接口，服务器只支持一个WebSocket主机并在同一时间内处理常用的服务器
NetworkTransport.AddWebSocketHost(topology,port,Ip);
// 例如：
NetworkTransport.AddWebSocketHost(topolagy,8888,null);

public abstract class MessageBase
{
// De-serialize the contents of the reader into this message
public virtual void Deserialize(NetworkReader reader) {}
// Serialize the contents of this message into the writer
public virtual void Serialize(NetworkWriter writer) {}
}
有内置message 类为常用的网络messages类型:

EmptyMessage
StringMessage
IntegerMessage

using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Networking.NetworkSystem;
 
public class SYTest : NetworkBehaviour
{
  const short MyTestMsg = 1024;
 
  NetworkClient m_client;
 
public void SendReadyToBeginMessage(int myID)
{
    var msg = new IntegerMessage(myId);
    m_client.Send(MyTestMsg , msg);
}
 
public void Init(NetworkClient client)
{
  m_client = client;
  NetworkServer.RegisterHandler(MyTestMsg , OnServerReadyToBeginMessage);
}
 
void OnServerReadyToBeginMessage(NetworkMessage netMsg)
{
  var beginMessage = netMsg.ReadMessage<IntegerMessage>();
  Debug.Log("received OnServerReadyToBeginMessage " + beginMessage.value);
}
}

// 声明一个自定义网络message类并 使用它:注意:ScoreMessage 类没有序列化代码。
using UnityEngine;
using UnityEngine.Networking;
 
public class Scores : MonoBehaviour
{
    NetworkClient myClient;
 
public class MyMsgType {
public static short Score = MsgType.Highest + 1;
};
 
public class ScoreMessage : MessageBase
{
public int score;
public Vector3 scorePos;
public int lives;
}
 
public void SendScore(int score, Vector3 scorePos, int lives)
{
ScoreMessage msg = new ScoreMessage();
msg.score = score;
msg.scorePos = scorePos;
msg.lives = lives;
 
NetworkServer.SendToAll(MyMsgType.Score, msg);
}
 
// Create a client and connect to the server port
public void SetupClient()
{
myClient = new NetworkClient();
myClient.RegisterHandler(MsgType.Connect, OnConnected);
myClient.RegisterHandler(MyMsgType.Score, OnScore);
myClient.Connect("127.0.0.1", 4444);
}
 
public void OnScore(NetworkMessage netMsg)
{
ScoreMessage msg = netMsg.ReadMessage<ScoreMessage>();
Debug.Log("OnScoreMessage " + msg.score);
}
 
public void OnConnected(NetworkMessage netMsg)
{
Debug.Log("Connected to server");
}
}

public virtual void OnClientEnterLobby()
{
}
public virtual void OnClientExitLobby()
{
}
public virtual void OnClientReady(bool readyState)
{
}

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include "RakClientInterface.h" //建立客服端所需要的信息，其中包括客服端的建立，连接和数据的发送和接收
#include "RakNetworkFactory.h" //用于管理我们在程序中使用的类，包括类内存分配和类内存的释放
#include "RakServerInterface.h" //用于建立服务器所需用的信息，包括服务器的建立，连接和数据的发送和接收
#include "PacketEnumerations.h" //用于处理网络引擎在运行过程中得到的信息
Packet *packet;//网络传输中用于存储数据的一个数据结构
/////////////////////////////////////////////////////
/*
Struct Packet
{
PlayerID playerId; //表明了包的出处。每一个连接服务器的客户端都将被分配一个唯一的ID号，用于标识自己。
Unsigned long length; //数据长度
Unsigned long bitsize; //比特大小
Char *data; //包中的数据
}
*/
/////////////////////////////////////////////////////
int main(void)
{
char str[512];
RakClientInterface *rakClientInterface;
RakServerInterface *rakServerInterface;
print("（C）客服端 (S)服务器?\n");
gets(str);
if (str[0]=='c')
{
//初始化一个客户端实例，为它分配内存
rakClientInterface=RakNetworkFactory::GetRakClientInterface();
rakServerInterface=0;
print("客服端已经建立。");
}
else
{
rakClientInterface=0;
//初始化一个服务器实例，为它分配内存
rakServerInterface=RakNetworkFactory::GetRakServerInterface();
print("服务器已经建立。");
}
if (rakServerInterface)
{
rakServerInterface->Start(32, 0, 0, 60000);// 服务器运行在端口60000处
/*第一个参数表明你的服务器允许同时连接多少个客户端,这个参数最大可以设置成65535;
第二个参数做保留之用，设置成0;
第三个参数用于设置多久进行服务器更新，参数要大于等于0，表示用每隔当前设置的毫秒数进行更新，这里设置的是0;
最后一个参数用于设置服务器的端口;*/
}
else
{
// 运行客户端
print("输入服务器[IP地址]：\n");
gets(str);
// 127.0.0.1默认
if (str[0]==0)
strcpy(str, "127.0.0.1");
rakClientInterface->Connect(str, 60000, 0, 0, 0);
/*第一个参数表示你要连接的服务器的IP地址，如果是在自己这台计算机调试程序，直接输入”127.0.0.1”或“localhost
第二个参数表示要连接的服务器的端口;
第三个参数表示要连接的客户端端口，主要就是用于客户端之间交换数据;
第四个参数不要;
第五个参数和服务器start函数中的第三个参数一样.*/
}
while (1)
{
if (rakServerInterface)
packet = rakServerInterface->Receive();
else
packet = rakClientInterface->Receive();
if (packet)
{
switch (packet->data[0])
{
case ID_REMOTE_DISCONNECTION_NOTIFICATION:
print("另一个连接已经断开.\n");
break;
case ID_REMOTE_CONNECTION_LOST:
print("一个客户端丢失连接.\n");
break;
case ID_REMOTE_NEW_INCOMING_CONNECTION:
print("一个客户端已上线.\n");
break;
case ID_CONNECTION_REQUEST_ACCEPTED:
print("我们的连接要求已经接受.\n");
break;
case ID_NEW_INCOMING_CONNECTION:
printf("有新连接.\n");
break;
case ID_NO_FREE_INCOMING_CONNECTIONS:
printf("服务器已满.\n");
break;
case ID_DISCONNECTION_NOTIFICATION:
if (rakServerInterface)
print("客户端丢失.\n");
else
printf("连接中断.\n");
break;
case ID_CONNECTION_LOST:
if (rakServerInterface)
printf("客户端丢失连接.\n");
else
printf("连接丢失.\n");
break;
default(
printf("ID信息 %i 已经到达.\n", packet->data[0]);
break;
}
if (rakServerInterface)
rakServerInterface->DeallocatePacket(packet);
else
rakClientInterface->DeallocatePacket(packet);
}
}
// TODO - Add code body here
//getch();
if (rakClientInterface)
RakNetworkFactory::DestroyRakClientInterface(rakClientInterface);
else if (rakServerInterface)
RakNetworkFactory::DestroyRakServerInterface(rakServerInterface);
return 0;
}