public static void Write(string dist, int length, string info)
{
var src = UniP2PManager.GetEnableIPEndPoint().ToString();
//Debug.Log(string.Format("Send:[{0}] Src:{2} Dist:{3} Length:{4} Info:{5} Time:{1}", counter,Time.realtimeSinceStartup, src, dist, length, info));
counter++;
}
void Spawn()
{
var obj = UniP2PManager.Instantiate(TankPath, Respowns[UniP2PManager.GetMyPeerOrder()].position, Respowns[UniP2PManager.GetMyPeerOrder()].rotation) as GameObject;
obj.GetComponent <TankShooting>().ShotButton = ShotButton;
Tanks.Add(obj.GetComponent <TankController>());
}
public static async UniTask <CheckRoomResponse> CheckRoomAsync()
{
var req = new CheckRoomRequest
{
peerid = UniP2PManager.MyPeerID,
roomid = CurrentRoomID,
token = CurrentToken
};
req.SetHash();
var result = await HttpClient.Post(GetURIGamekey(UniP2PManager.MatchingSettings.MatchingServerURI) + "/rooms/check", JsonUtility.ToJson(req));
if (result.StatusCode == 200)
{
var room = JsonUtility.FromJson <CheckRoomResponse>(result.Text);
foreach (var p in room.peers)
{
if (p.id != UniP2PManager.MyPeerID && UniP2PManager.GetConnectedPeer(p.id) == null)
{
await UniP2PManager.SendEmptyPacketAsync(IPEndPointParser.Parse(p.ip));
}
}
return(room);
}
else
{
Debug.Debugger.Warning("[SimpleMatchingClient] CheckRoomAsync StatusCode:" + result.StatusCode + ":" + JsonUtility.ToJson(req));
return(null);
}
}
public static async UniTask JoinRoom(MatchingLANPacket info)
{
foreach (var ip in info.PeerIPEndPoints)
{
await UniP2PManager.ConnectPeerAsync(IPEndPointParser.Parse(ip));
}
}
private async void Start()
{
SyncGameObject = GetComponent <SyncGameObject>();
await UniTask.Delay(500);
connectedpeertext.text = "Connected Peer:" + UniP2PManager.GetPeerConnectedCount();
LogUpdate();
await RpcTest();
LogUpdate();
await SendData();
LogUpdate();
await SendByteArray();
LogUpdate();
await UniTask.Delay(500);
foreach (var peer in UniP2PManager.GetAllPeer())
{
if (peer.State == PeerState.Connected)
{
var ms = await UniP2PManager.Ping(peer);
pingtext.text = peer.ID + ":" + ms + "ms" + "\n";
}
}
}
public static async UniTask Destroy(Object obj, SocketQosType qostype = SocketQosType.Unreliable)
{
var gameObject = (GameObject)obj;
await UniP2PManager.SendPacketAllPeerAsync(CreatePacket(DataEventPacket.Destroy, null, gameObject.GetComponent <SyncGameObject>().InstanceID), CommandType.DataEvent, qostype);
Object.Destroy(gameObject);
}
private async void Update()
{
if (Input.GetKeyDown(KeyCode.Q))
{
await UniP2PManager.DisConnectAllPeerAsync();
Application.Quit();
}
}
public static async UniTask SendStream(string instanceid, string eventname, string typename, byte[] value, SocketQosType qostype = SocketQosType.Unreliable, string peerid = "")
{
var peer = UniP2PManager.GetPeer(peerid);
if (peer == null)
{
return;
}
await UniP2PManager.SendPacketAsync(peer, CreatePacket(eventname, value, instanceid, typename), CommandType.DataEvent, qostype);
}
public static async UniTask <Object> Instantiate(string resourcepath, Vector3 position, Quaternion quaternion, SocketQosType qostype = SocketQosType.Unreliable)
{
var obj = Object.Instantiate(Resources.Load(resourcepath), position, quaternion);
var gameObject = (GameObject)obj;
var id = gameObject.GetComponent <SyncGameObject>().Instance(UniP2PManager.MyPeerID);
var buf = Serializer.Serialize(new InstantiateInfomation {
Position = position, Quaternion = quaternion, ResourcePath = resourcepath
});
await UniP2PManager.SendPacketAllPeerAsync(CreatePacket(DataEventPacket.Instantiate, buf, id), CommandType.DataEvent, qostype);
return(obj);
}
public static async UniTask <bool> JoinRoomAsync(string roomid, bool isconnect = true, bool beforedisconnect = true)
{
var req = new JoinRoomRequest
{
peerid = UniP2PManager.MyPeerID,
roomid = roomid,
ip = IPEndPointParser.ToString(UniP2PManager.GetEnableIPEndPoint()),
localport = UniP2PManager.PrivateIPEndPoint.Port
};
req.SetHash();
var result = await HttpClient.Post(GetURIGamekey(UniP2PManager.MatchingSettings.MatchingServerURI) + "/rooms/join", JsonUtility.ToJson(req));
if (result.StatusCode == 200)
{
var room = JsonUtility.FromJson <JoinRoomResponse>(result.Text);
CurrentRoomID = roomid;
CurrentToken = room.token;
if (isconnect)
{
if (beforedisconnect)
{
await UniP2PManager.DisConnectAllPeerAsync();
}
foreach (var peer in room.peers)
{
if (peer.id == UniP2PManager.MyPeerID)
{
continue;
}
await UniP2PManager.SendEmptyPacketAsync(IPEndPointParser.Parse(peer.ip));
await UniTask.Delay(100);
await UniP2PManager.ConnectPeerAsync(IPEndPointParser.Parse(peer.ip), peer.id, (int)peer.localport);
}
}
return(true);
}
else
{
Debug.Debugger.Warning("[SimpleMatchingClient] JoinRoomAsync StatusCode:" + result.StatusCode + ":" + JsonUtility.ToJson(req));
return(false);
}
}
private async UniTask CheckHeartBeatAsync()
{
while (State == UdpConnectionState.Connected)
{
await UniTask.Delay(10000);
if (isReceiveHeartBeat)
{
isReceiveHeartBeat = false;
}
else
{
Debug.Debugger.Log("[UdpConnection] Time Out Peer:" + Peer.ID);
await UniP2PManager.DisConnectPeerAsync(Peer);
}
}
}
public static async UniTask <bool> JoinRandomRoomAsync(bool isconnect = true, bool beforedisconnect = true)
{
var req = new JoinRandomRoomRequest
{
peerid = UniP2PManager.MyPeerID,
ip = IPEndPointParser.ToString(UniP2PManager.GetEnableIPEndPoint())
};
req.SetHash();
var result = await HttpClient.Post(GetURIGamekey(UniP2PManager.MatchingSettings.MatchingServerURI) + "/rooms/joinrandom", JsonUtility.ToJson(req));
if (result.StatusCode == 200)
{
var room = JsonUtility.FromJson <JoinRandomRoomResponse>(result.Text);
CurrentRoomID = room.roomid;
CurrentToken = room.token;
if (isconnect)
{
if (beforedisconnect)
{
await UniP2PManager.DisConnectAllPeerAsync();
}
List <UniTask <Peer> > tasks = new List <UniTask <Peer> >();
foreach (var peer in room.peers)
{
if (peer.id != UniP2PManager.MyPeerID)
{
var task = UniP2PManager.ConnectPeerAsync(IPEndPointParser.Parse(peer.ip), peer.id);
tasks.Add(task);
}
}
await UniTask.WhenAll(tasks);
}
return(true);
}
else
{
Debug.Debugger.Warning("[SimpleMatchingClient] JoinRandomRoomAsync StatusCode:" + result.StatusCode + ":" + JsonUtility.ToJson(req));
return(false);
}
}
public async UniTask <Peer> ConnectPeerAsync(IPEndPoint ip, string peerid = "", int localport = 0)
{
var peer = new Peer
{
State = PeerState.Connecting,
ID = peerid,
};
var udp = new UdpConnection(peer);
UdpConnections.Add(udp);
udp.State = UdpConnectionState.RequestSend;
int i = 0;
do
{
await SendConnectRequestEvent(ip);
if (i >= 3 && localport != 0)
{
Debugger.Log("[SocketUDP] LAN Connect Port:" + localport);
await SendConnectRequestEvent(ip, true, localport);
}
if (i >= 5)
{
Debugger.Error("[SocketUDP] Timeout: " + ip.ToString());
UniP2PManager.RemovePeer(peer);
return(null);
}
await UniTask.Delay(1000);
i++;
}while (peer.State != PeerState.Connected);
return(peer);
}
public Peer()
{
UniP2PManager.AddPeer(this);
}
private async UniTask CheckRoom()
{
var r = await SimpleMatchingClient.CheckRoomAsync();
if (r != null)
{
#if UNITY_EDITOR
if (!EditorApplication.isPlaying)
{
return;
}
#endif
CurrentMemberText.text = string.Format("Current Member {0}/5" + "\n" + "Connected Peer: {1}", r.peers.Length, UniP2PManager.GetPeerConnectedCount());
if (r.isclose)
{
isWaiting = false;
isPlay = true;
await SceneManager.LoadSceneAsync(GamePlaySceneName);
DataEventManager.IsDataEventQueueing = false;
}
}
}
private async UniTask OnReceiveCompletedAsync(byte[] buffer, IPEndPoint remote)
{
if (Equals(remote, UniP2PManager.PrivateIPEndPoint) || Equals(remote, UniP2PManager.StunIPEndPoint))
{
Debugger.Warning("[UniP2PManager] IPEndPoint is MySelf.");
return;
}
UdpPacket packet = null;
try
{
packet = UdpPacket.Deserialize(buffer);
}
catch (Exception ex)
{
//Debugger.Warning(ex.Message + remote.ToString());
return;
}
if (packet.PeerID != null)
{
var udp = GetUdpConnection(packet.PeerID);
if (udp != null)
{
if (udp.State == UdpConnectionState.Connected)
{
if (packet.isEncrypt())
{
var decrypt = AES.Decrypt(packet.UdpPacketL2, udp.AESKey, packet.UdpPacketL2IV);
var l2 = UdpPacketL2.Deserialize(decrypt);
if (l2.ACKNumber != 0)
{
udp.ReceiveACKPacket(l2.ACKNumber);
}
//Reliable
if (l2.PacketNumber != 0)
{
//Reply ACK
}
foreach (var command in l2.Commands)
{
if (command.P2PEventType == CommandType.Disconnect)
{
Debugger.Log("[SocketUDP] DisConnect PeerID:" + udp.Peer.ID);
udp.DisConnect();
UdpConnections.Remove(udp);
UniP2PManager.RemovePeer(udp.Peer);
return;
}
else if (command.P2PEventType == CommandType.HeartBeat)
{
udp.ReceiveHeartBeat();
}
else if (command.P2PEventType == CommandType.Nothing || command.P2PEventType == CommandType.DataEvent)
{
var e = new P2PEventArgs(udp.Peer, command.P2PEventType, command.Value);
ReceiveSubject.OnNext(e);
}
}
}
else
{
var l2 = UdpPacketL2.Deserialize(packet.UdpPacketL2);
foreach (var command in l2.Commands)
{
if (command.P2PEventType == CommandType.HeartBeat)
{
udp.ReceiveHeartBeat();
}
}
}
}
else if (udp.State == UdpConnectionState.KeyExchange)
{
var l2 = UdpPacketL2.Deserialize(packet.UdpPacketL2);
foreach (var command in l2.Commands)
{
if (command.P2PEventType == CommandType.RequestKey)
{
await udp.CreateKey(command.Value, UdpSocket, this);
break;
}
else if (command.P2PEventType == CommandType.AcceptKey)
{
udp.AcceptKey(command.Value, this);
break;
}
}
}
else if (udp.State == UdpConnectionState.RequestSend)
{
var l2 = UdpPacketL2.Deserialize(packet.UdpPacketL2);
foreach (var command in l2.Commands)
{
if (command.P2PEventType == CommandType.RequestAccept)
{
await ReceiveConnectAcceptEvent(udp, remote);
break;
}
}
}
else if (udp.State == UdpConnectionState.DisConnect)
{
udp.DisConnect();
return;
}
}
else
{
//Not Found Udp Connection
var l2 = UdpPacketL2.Deserialize(packet.UdpPacketL2);
foreach (var command in l2.Commands)
{
if (command.P2PEventType == CommandType.ConnectRequest)
{
var peer = new Peer
{
ID = packet.PeerID,
IPEndPoint = remote,
};
await ReceiveConnectRequestEvent(peer);
}
else if (command.P2PEventType == CommandType.PingRequest)
{
await SendPingResponsePacketAsync(remote, PingPacket.Deserialize(command.Value).PingID);
}
else if (command.P2PEventType == CommandType.PingResponse)
{
ReceivePingResponsePacketAsync(PingPacket.Deserialize(command.Value).PingID);
}
}
}
}
else
{
var l2 = UdpPacketL2.Deserialize(packet.UdpPacketL2);
foreach (var command in l2.Commands)
{
if (command.P2PEventType == CommandType.PingRequest)
{
await SendPingResponsePacketAsync(remote, PingPacket.Deserialize(command.Value).PingID);
}
else if (command.P2PEventType == CommandType.PingResponse)
{
ReceivePingResponsePacketAsync(PingPacket.Deserialize(command.Value).PingID);
}
}
}
}
public static async UniTask SendStreamAllPeer(string instanceid, string eventname, string typename, byte[] value, SocketQosType qostype = SocketQosType.Unreliable)
{
await UniP2PManager.SendPacketAllPeerAsync(CreatePacket(eventname, value, instanceid, typename),
CommandType.DataEvent, qostype);
}
