//广播给所有人 public void BroadcastPackage(NetPackage pacakge) { foreach (var item in _playerMap) { item.Value.worker.SendPackage(pacakge); } }
public void SendPackage(NetPackage package) { if (!stop) { broadcastWorker.SendPackage(package); } }
public bool Send(byte[] buffer, ushort option) { NetPackage np = new NetPackage(net.NET_HEADER_SIZE, net.NET_BUFF_SIZE); if ((buffer.Length + net.NET_HEADER_SIZE) > net.NET_BUFF_SIZE) { return(false); } np.size = buffer.Length + net.NET_HEADER_SIZE; Buffer.BlockCopy(buffer, 0, np.data, net.NET_HEADER_SIZE, buffer.Length); np.header.netId = net.NET_ID; np.header.option = option; if (sentNumber < 1) { sentNumber++; } np.header.number = sentNumber++; byte[] tmpBuff = net.NetHeaderToByteArray(np.header); np.header.checksum = (ushort)net.ComputeChecksum(buffer); Buffer.BlockCopy(net.NetHeaderToByteArray(np.header), 0, np.data, 0, net.NET_HEADER_SIZE); m_sendingPacks.Add(np); return(true); }
public void DoWork() { while (true) { lock (clientConnWorkerList) { for (int i = clientConnWorkerList.Count - 1; i >= 0; i--) { ClientConnectionWorker worker = clientConnWorkerList[i]; if (worker.HasDisConnection()) { clientConnWorkerList.Remove(worker); worker.Stop(); worker.Dispose(); continue; } lock (worker.readPackageQueue) { while (worker.readPackageQueue.Count > 0) { NetPackage package = worker.readPackageQueue.Dequeue(); try{ ((TcpPackage)package).ServerDo(worker); }catch (System.Exception e) { Debug.LogError(e.StackTrace); } } } } } Thread.Sleep(1); } }
private void ReceiveThread() { NetworkHelper net = NetworkHelper.GetInstance(); Debug.WriteLine("Listener started!"); for (int i = 0; i < 5; i++) { Thread.Sleep(100); Debug.WriteLine("Check!"); if (net.PackageQueueCount() > 0) { NetPackage received = net.PopPackage(); NetCommand cmd = received.NetCommand; _receivedFlag = true; if (cmd.GetCommandHeader() == "test" && cmd.GetCommandData() == "test_data") { _okFlag = true; } ; } } Debug.WriteLine("Timeout fail!"); }
private void Receive_ServerSenddata(NetPackage package) { scBroadcastIP mServerSendData = Protocol3Utility.getData <scBroadcastIP> (package.buffer, 0, package.buffer.Length); DebugSystem.Log("Server: " + mServerSendData.Ip); nReceiveCount++; }
public void SendPackage(NetPackage package) { lock (writePackageQueue) { writePackageQueue.Enqueue(package); } }
private void Receive_ServerSenddata(NetPackage package) { //DebugSystem.Log ("Client packageLength: " + package.Length); csChatData mServerSendData = Protocol3Utility.getData <csChatData> (package); //DebugSystem.Log ("Client: " + mServerSendData.Id + " | " + mServerSendData.TalkMsg); UDPServerTest.nReceiveCount++; }
public void SendPackage(NetPackage package) { if (serverConnectionWorker == null || !isConnection) { return; } serverConnectionWorker.SendPackage(package); }
/// <summary> /// Send data to Listener /// </summary> /// <param name="package"></param> public void Send(NetPackage package, Action <object> handleResult = null, IPEndPoint endpoint = null) { if (package.Data.Length > 0) { _PackageQueue.Add(new SendUnit { Pakage = package, Handler = handleResult, Endpoint = (endpoint == null ? this._serverSettings.GetServerAddress() : endpoint) }); } }
public NetPackage ReadPackage(NetPackage package) { int length = br.ReadInt32(); int id = br.ReadInt32(); byte[] data = br.ReadBytes(length - 8); package.Deserialize(data); return(package); }
private void OnAccept(IAsyncResult iar) { TcpListener l = (TcpListener)iar.AsyncState; if (l == null) { return; } TcpClient c; try { c = l.EndAcceptTcpClient(iar); using (_NetworkStream = c.GetStream()) { NetPackage response = this._handler.ProcessRequest(_NetworkStream, (ev) => { this.OnEvent(this, (ServiceEvent)ev); }); if (response != null) { _NetworkStream.Write(response.Data, 0, response.Data.Length); } } // keep listening l.BeginAcceptTcpClient(new AsyncCallback(OnAccept), l); } catch (SocketException ex) { Console.WriteLine("Error accepting TCP connection: {0}", ex.Message); // unrecoverable //// _doneEvent.Set(); return; } catch (ObjectDisposedException) { // The listener was Stop()'d, disposing the underlying socket and // triggering the completion of the callback. We're already exiting, // so just return. Console.WriteLine("Listen canceled."); return; } catch (Exception ex) { return; } // meanwhile... //SslStream s = new SslStream(c.GetStream()); //Console.WriteLine("Authenticating..."); //s.BeginAuthenticateAsServer(_cert, new AsyncCallback(OnAuthenticate), s); }
public void WritePackage(NetPackage package) { package.Serialize(); MemoryStream ms = package.GetMemoryStream(); byte[] buffer = ms.GetBuffer(); int length = (int)ms.Length; bw.Write(buffer, 0, length); }
private void Receive_ServerSenddata(ClientPeer peer, NetPackage package) { //DebugSystem.Log ("Server packageLength: " + package.nOrderId + "|" + package.nPackageId + " | " + package.nGroupCount + " | " + package.Length); csChatData mServerSendData = Protocol3Utility.getData <csChatData> (package); //mServerSendData.Id = peer.getPort (); //DebugSystem.Log ("Server: " + mServerSendData.TalkMsg); nServerReceiveCount++; peer.SendNetData(UdpNetCommand.COMMAND_TESTCHAT, mServerSendData); }
private void NetworkReadTimer_Tick(object sender, EventArgs e) { NetworkHelper net = NetworkHelper.GetInstance(); if (net.PackageQueueCount() > 0) { NetPackage package = net.PeekPackage(); ProcessNetworkCommand(package.NetCommand, package.Sender); } }
//广播给所有人 public void BroadcastPackage(NetPackage pacakge, ClientPlayer broadcastSource, bool includeSelf = true) { foreach (var item in _playerMap) { if (!includeSelf && broadcastSource.id == item.Value.id) { continue; } item.Value.worker.SendPackage(pacakge); } }
public void DeSerialize(NetPackage mPackage) { if (mLogicFuncDic.ContainsKey(mPackage.command)) { mLogicFuncDic [mPackage.command] (mPackage); } else { DebugSystem.LogError("不存在的 协议ID: " + mPackage.command); } }
public void BroadcastPackageInEntityViewPlayers(NetPackage package, ClientEntity clientEntity, int besidePlayerId) { for (int i = 0; i < clientEntity.viewPlayers.Count; i++) { int id = clientEntity.viewPlayers[i]; if (id != besidePlayerId) { ClientPlayer player = NetManager.Instance.server.playerManager.GetPlayer(id); player.worker.SendPackage(package); } } }
public bool Send(ProtocolBase protocol) { if (status != Status.Connected) { Console.WriteLine("尚未连接,发送失败"); return(false); } byte[] sendBuff = NetPackage.EncoderHeader(protocol); socket.Send(sendBuff); //Debug.Log("发送消息 " + protocol.GetDesc()); return(true); }
private void Receive_ServerSenddata(NetPackage package) { //csChatData mServerSendData = Protocol3Utility.getData<csChatData> (package.buffer, 0, package.buffer.Length); //scChatData mSenddata = new scChatData (); //mSenddata.ChatInfo = new struct_ChatInfo (); //mSenddata.ChatInfo.ChannelId = mServerSendData.ChannelId; //mSenddata.ChatInfo.TalkMsg = mServerSendData.TalkMsg; //mNetSystem.sendNetData (package.clientId, (int)ProtoCommand.ProtoChat, mSenddata); //nReceiveCount++; //Debug.Log ("Server接受数量: " + mServerSendData.ChannelId + "| " + ++nReceiveCount); }
public void BroadcastPackage(NetPackage package, ClientPlayer broadcastSource, int broadcastChunkWidth, bool includeSelf = true) { WorldPos chunkPos = broadcastSource.inChunkPos; for (int x = -broadcastChunkWidth; x <= broadcastChunkWidth; x++) { for (int z = -broadcastChunkWidth; z <= broadcastChunkWidth; z++) { chunkPosList.Add(new WorldPos(chunkPos.x + x * Chunk.chunkWidth, chunkPos.y, chunkPos.z + z * Chunk.chunkDepth)); } } playerManager.BroadcastChunkPackage(package, broadcastSource, chunkPosList, includeSelf); chunkPosList.Clear(); }
private void NetworkReadTimer_Tick(object sender, EventArgs e) { NetworkHelper net = NetworkHelper.GetInstance(); if (net.PackageQueueCount() > 0) { Debug.WriteLine($"Checking net queue. {net.PackageQueueCount()} commands received"); NetPackage package = net.PeekPackage(); ProcessNetworkCommand(package.NetCommand, package.Sender); } else { Debug.WriteLine("Checking net queue. No commands received"); } }
public void OnServerResponse(NetPackage package, byte [] bytes) { if (package.ActionId == 2) { } else { GameServerMsg msg = new GameServerMsg(package, bytes); QueueEvent(new ServerResponseEvent(msg)); if (package.ActionId == 0x05a1) { Net.Instance.Close(); Debug.LogWarning("账号被挤"); } } }
IEnumerator ListenReceive() { while (!stop) { lock (broadcastWorker.readPackageQueue) { while (broadcastWorker.readPackageQueue.Count > 0) { NetPackage package = broadcastWorker.readPackageQueue.Dequeue(); ((UdpPackage)package).Do(); } } yield return(new WaitForSeconds(0.5f)); } yield return(null); }
public void BroadcastChunkPackage(NetPackage package, ClientPlayer broadcastSource, List <WorldPos> chunkPosList, bool includeSelf) { for (int i = 0; i < chunkPosList.Count; i++) { List <ClientPlayer> listPlayer = GetPlayersInChunk(chunkPosList[i]); if (listPlayer != null) { for (int j = 0; j < listPlayer.Count; j++) { if (!includeSelf && listPlayer[j].id == broadcastSource.id) { continue; } listPlayer[j].worker.SendPackage(package); } } } }
public void Listener() { try { networkHelper.MessageReceiver(Callback, Listener); NetPackage AddressMessage = callback; string message = Encoding.Unicode.GetString(AddressMessage.Data); IPAddress iPAddress = AddressMessage.Sender; MessageDisplay.Enabled = true; this.MessageDisplay.BeginInvoke(new InvokeDelegate(AddMessage), iPAddress, message, " получено"); Listener(); } catch (Exception ex) { Debug.WriteLine(ex); } }
/// <summary> /// /// </summary> /// <param name="data"></param> /// <returns>object type in order to not depend on serializer interfaces</returns> public NetPackage Pack(object data) { if (!(data is IMessage)) { throw new CommunicationException("Only IMessage data allowed!"); } RemotingCommands type = (RemotingCommands)data.GetType().GetProperty("Type").GetValue(data, null); // buffer stores type of message byte[] typeBuff = BitConverter.GetBytes((int)type); // message body byte[] bodyBuff = ((IMessage)data).ToByteArray(); // buffer stores total length of significant data byte[] totalLengthBuff = BitConverter.GetBytes(typeBuff.Length + bodyBuff.Length); return(NetPackage.Create(totalLengthBuff.Combine(typeBuff).Combine(bodyBuff))); }
public byte[] Pack(NetPackage package) { this.WriteToPackageBytes(0); this.WriteToPackageBytes(package.MsgId); this.WriteToPackageBytes(0); this.WriteToPackageBytes(package.ProtocId); this.WriteToPackageBytes(0); this.WriteToPackageBytes(package.Type); this.WriteToPackageBytes(package.Version); this.WriteToPackageBytes(package.Data); var bytes = packageBytes; var bytesLen = BitConverter.GetBytes(bytes.Length + 4); bytes = this.CombineBytes(bytesLen, bytes); this.ClearPackageBytes(); return(bytes); }
public override void Handler(NetPackage package) { base.Handler(package); JumpPackage = (JumpCommandPackage)package; if (JumpPackage.command == 1) { if (On_Jump != null) { On_Jump(); } } else { if (On_JumpEnd != null) { On_JumpEnd(); } } }
public override void Handler(NetPackage package) { base.Handler(package); MovePackage = (MoveCommandPackage)package; if (MovePackage.dir.x == 0 && MovePackage.dir.y == 0) { if (On_MoveEnd != null) { On_MoveEnd(); } } else { if (On_Move != null) { On_Move(MovePackage.dir); } } }
private void OnRespond(NetPackage package) { NetReader reader = package.Reader; bool result = true; if (CommonCallback != null) { result = CommonCallback(reader); } if (result && package.Action != null && package.Action.TryDecodePackage(reader)) { package.Action.Callback(package.UserData); } else { Debug.Log("Decode package fail."); } }