public virtual void SendMessage(ITcpMessage message)
{
MessageQueue.Enqueue(message);
_semaphore.Wait();
try
{
if (NetworkStream.CanWrite)
{
var byteArray = message.GetMessage();
var messageLen = BitConverter.GetBytes(byteArray.Length);
ReadWriteStream.Write(messageLen);
ReadWriteStream.Flush();
ReadWriteStream.Write(byteArray);
ReadWriteStream.Flush();
}
}
finally
{
MessageQueue.TryDequeue(out var massage);
_semaphore.Release();
}
}
public virtual async Task SendMessageAsync(ITcpMessage message, CancellationToken token)
{
MessageQueue.Enqueue(message);
await _semaphore.WaitAsync(token).ConfigureAwait(false);
try
{
if (NetworkStream.CanWrite)
{
var byteArray = message.GetMessage();
var messageLen = BitConverter.GetBytes(byteArray.Length);
await ReadWriteStream.WriteAsync(messageLen, token)
.ConfigureAwait(false);
await ReadWriteStream.FlushAsync(token)
.ConfigureAwait(false);
await ReadWriteStream.WriteAsync(byteArray, token)
.ConfigureAwait(false);
await ReadWriteStream.FlushAsync(token)
.ConfigureAwait(false);
}
}
finally
{
MessageQueue.TryDequeue(out var massage);
_semaphore.Release();
}
}
public Packet CreatePacket(ITcpMessage message)
{
Packet packet = new Packet();
packet.SendByte((byte)message.MessageType);
switch (message)
{
case PacketClientJoinMessage j:
{
packet.SendString(j.OpenttdRevision);
packet.SendU32(j.NewgrfVersion);
packet.SendString(j.ClientName);
packet.SendByte(j.JoinAs);
packet.SendByte(j.Language);
break;
}
case PacketClientGamePasswordMessage p:
{
packet.SendString(p.Password);
break;
}
case PacketClientAckMessage ack:
{
packet.SendU32(ack.FrameCounter);
packet.SendByte(ack.Token);
break;
}
case PacketClientChatMessage chat:
{
packet.SendByte((byte)(((byte)NetworkAction.NETWORK_ACTION_CHAT) + ((byte)chat.ChatDestination)));
packet.SendByte((byte)chat.ChatDestination);
packet.SendU32(chat.Destination);
packet.SendString(chat.Message);
packet.SendU64(chat.Data);
break;
}
case GenericTcpMessage _:
{
// here we have only messages that have only type
break;
}
default:
{
throw new NotImplementedException(message.MessageType.ToString());
}
}
packet.PrepareToSend();
return(packet);
}
void HandleTcpMessage(ITcpMessage msg)
{
switch (msg)
{
case ObjectCreatedMessage objMsg:
{
var id = objMsg.ObjectId;
Objects[id] = new SyncObject(this, id, objMsg.OriginalNodeId);
if (creationQueue.Count > 0 && objMsg.OriginalNodeId == NodeId)
{
lock (creationQueue)
{
creationQueue.Dequeue().SetResult(id);
}
}
Logger.Debug("Client", $"Received ObjectId={id}");
InvokeObjectCreated(id);
break;
}
case ObjectDeletedMessage delMsg:
{
var id = delMsg.ObjectId;
Objects.Remove(id);
Logger.Debug("Client", $"Received Deletion of ObjectId={id}");
InvokeObjectDeleted(id);
break;
}
case SymbolRegisteredMessage symMsg:
{
SymbolTable.Add(symMsg.Symbol, symMsg.SymbolId);
if (symbolNotifier.IsWaiting(symMsg.Symbol))
{
symbolNotifier.Notify(symMsg.Symbol, symMsg.SymbolId);
}
Logger.Debug("Client", $"Received Symbol {symMsg.Symbol}->{symMsg.SymbolId}");
break;
}
case EventSentMessage eventSentMessage:
{
HandleEventSentMessage(
eventSentMessage.Name,
eventSentMessage.Sender, eventSentMessage.Receiver,
eventSentMessage.Args
);
break;
}
}
}
public HttpServer(int port, List <Route> routes, ITcpMessage tcpMessage_ = null)
{
this.Port = port;
this.Processor = new HttpProcessor(tcpMessage_);
foreach (var route in routes)
{
this.Processor.AddRoute(route);
}
}
private void TcpClient_MessageReceived(object sender, ITcpMessage e)
{
switch (e.MessageType)
{
case TcpMessageType.PACKET_SERVER_CHAT:
{
var m = e as PacketServerChatMessage;
if (m.ClientId == this.tcpClient.MyClientId)
{
break;
}
ChatDestination destination = (ChatDestination)((int)m.NetworkAction - (int)NetworkAction.NETWORK_ACTION_CHAT);
if (new ChatDestination[] { ChatDestination.DESTTYPE_BROADCAST, ChatDestination.DESTTYPE_CLIENT, ChatDestination.DESTTYPE_TEAM }.Contains(destination))
{
this.ReceivedChatMessage?.Invoke(this, new ReceivedChatMessage(m.Message, tcpClient.Players[m.ClientId], destination, this.ServerInfo));
}
break;
}
}
}
public async void UpdateEvents(CancellationToken token)
{
while (token.IsCancellationRequested == false)
{
ITcpMessage message = null;
try
{
if (receivedMessageQueue.TryDequeue(out message))
{
this.MessageReceived?.Invoke(this, message);
}
if (receivedMessageQueue.IsEmpty)
{
await Task.Delay(TimeSpan.FromSeconds(0.5));
}
}
catch (Exception e)
{
this.logger.LogError(e, $"Error with {message?.MessageType}");
}
}
}
/// <summary>
/// Sends the MSG.
/// </summary>
/// <param name="msg">The MSG.</param>
public void SendMsg(ITcpMessage msg)
{
this.MessageQueue.Enqueue(msg);
this.waitHandle.Set();
}
public HttpProcessor(ITcpMessage tcpMessage_)
{
this.tcpMessage = tcpMessage_;
}
public TcpHandler(int port, ITcpMessage tcpMessage_ = null)
{
this.tcpMessage = tcpMessage_;
this.Port = port;
this.Listener = new TcpListener(IPAddress.Any, this.Port);
}
/// <summary>
/// 发送一般消息
/// </summary>
/// <param name="raw">可转换Json格式的实体类，并继承BaseMessage</param>
public bool Send(ITcpMessage raw)
{
return(Send(Encoding.UTF8.GetBytes($"<jsonMsg>{JsonConvert.SerializeObject(raw)}</jsonMsg>")));
}
public TcpMessageReceivedEventArgs(ITcpClientConnection client, ITcpMessage message)
{
Message = message;
TcpClient = client;
}
public async void MainLoop(CancellationToken token, string serverIp, int serverPort, string username, string password, string revision, uint newgrfRevision)
{
Task <int> sizeTask = null;
byte[] sizeBuffer = new byte[2];
int sizeBufferPos = 0;
while (token.IsCancellationRequested == false)
{
try
{
if (this.ConnectionState == ConnectionState.NotConnected)
{
sizeTask = null;
this.Reset();
this.ConnectionState = ConnectionState.Connecting;
client.Connect(serverIp, serverPort);
await this.QueueMessage(new PacketClientJoinMessage()
{
ClientName = username,
JoinAs = 255,
Language = 0,
OpenttdRevision = revision,
NewgrfVersion = newgrfRevision
});
}
for (int i = 0; i < 100; ++i)
{
if (this.sendMessageQueue.TryDequeue(out ITcpMessage msg))
{
Packet packet = this.tcpPacketService.CreatePacket(msg);
await client.GetStream().WriteAsync(packet.Buffer, 0, packet.Size);
}
else
{
break;
}
}
while ((sizeTask ??= client.GetStream().ReadAsync(sizeBuffer, sizeBufferPos, 2 - sizeBufferPos)).IsCompleted)
{
sizeBufferPos += sizeTask.Result;
if (sizeBufferPos == 1)
{
sizeTask = client.GetStream().ReadAsync(sizeBuffer, sizeBufferPos, 2 - sizeBufferPos);
await sizeTask;
}
sizeBufferPos = 0;
sizeTask = null;
sizeTask = null;
ushort size = BitConverter.ToUInt16(sizeBuffer, 0);
byte[] content = new byte[size];
content[0] = sizeBuffer[0];
content[1] = sizeBuffer[1];
int contentSize = 2;
do
{
Task <int> task = client.GetStream().ReadAsync(content, contentSize, size - contentSize);
await task;
contentSize += task.Result;
} while (contentSize < size);
var packet = new Packet(content);
ITcpMessage msg = this.tcpPacketService.ReadPacket(packet);
switch (msg.MessageType)
{
case TcpMessageType.PACKET_SERVER_FULL:
{
this.logger.LogWarning($"Cannot join {serverIp}:{serverPort} - server is full");
await Task.Delay(TimeSpan.FromMinutes(1));
this.Reset();
break;
}
case TcpMessageType.PACKET_SERVER_BANNED:
{
this.logger.LogWarning($"Cannot join {serverIp}:{serverPort} - user is banned");
await Task.Delay(TimeSpan.FromMinutes(10));
this.Reset();
break;
}
case TcpMessageType.PACKET_SERVER_NEED_GAME_PASSWORD:
{
await this.QueueMessage(new PacketClientGamePasswordMessage(password));
break;
}
case TcpMessageType.PACKET_SERVER_FRAME:
{
var m = msg as PacketServerFrameMessage;
await this.QueueMessage(new PacketClientAckMessage(m.FrameCounter, m.Token));
this.ConnectionState = ConnectionState.Connected;
this.connected = true;
break;
}
case TcpMessageType.PACKET_SERVER_CHECK_NEWGRFS:
{
await this.QueueMessage(new GenericTcpMessage(TcpMessageType.PACKET_CLIENT_NEWGRFS_CHECKED));
break;
}
case TcpMessageType.PACKET_SERVER_CLIENT_INFO:
{
var m = msg as PacketServerClientInfoMessage;
var player = new Player(m.ClientId, m.ClientName);
this.players.AddOrUpdate(m.ClientId, player, (_, __) => player);
if (connected)
{
this.receivedMessageQueue.Enqueue(msg);
}
break;
}
case TcpMessageType.PACKET_SERVER_QUIT:
{
var m = msg as PacketServerQuitMessage;
this.players.TryRemove(m.ClientId, out _);
this.receivedMessageQueue.Enqueue(msg);
break;
}
case TcpMessageType.PACKET_SERVER_ERROR_QUIT:
{
var m = msg as PacketServerErrorQuitMessage;
this.players.TryRemove(m.ClientId, out _);
this.receivedMessageQueue.Enqueue(msg);
break;
}
case TcpMessageType.PACKET_SERVER_WELCOME:
{
var m = msg as PacketServerWelcomeMessage;
this.MyClientId = m.ClientId;
await this.QueueMessage(new GenericTcpMessage(TcpMessageType.PACKET_CLIENT_GETMAP));
this.ConnectionState = ConnectionState.DownloadingMap;
break;
}
case TcpMessageType.PACKET_SERVER_MAP_DONE:
{
await this.QueueMessage(new GenericTcpMessage(TcpMessageType.PACKET_CLIENT_MAP_OK));
break;
}
default:
{
if (connected == false)
{
break;
}
this.receivedMessageQueue.Enqueue(msg);
break;
}
}
}
await Task.Delay(1);
}
catch (Exception e)
{
this.logger.LogError(e, $"Client failure: {nameof(TcpOttdClient)}:{nameof(MainLoop)} for {serverIp}:{serverPort}");
this.Reset();
#if DEBUG
await Task.Delay(5_000); // wait small amount of time xD before reconnecting.
#else
await Task.Delay(60_000); // wait 60 seconds before reconnecting.
#endif
}
}
this.ConnectionState = ConnectionState.NotConnected;
}
public Task QueueMessage(ITcpMessage message)
{
this.sendMessageQueue.Enqueue(message);
return(Task.CompletedTask);
}
