//广播给所有人
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.");
}
}
