public ServerNetworkGameStateContext(
NetIncomingMessageBusService <NetServer> netIncomingMessageBusService,
NetOutgoingMessageBusService <NetServer> netOutgoingMessageBusService,
IInputTranslator <NetIncomingMessage, NetworkCommandConnection> networkCommandServerTranslator,
IGameStateService <byte, TWorld> gameStateService,
ILogger <byte> logger)
{
CurrentNetIncomingMessageBusService = netIncomingMessageBusService ?? throw new ArgumentNullException(nameof(netIncomingMessageBusService));
CurrentNetOutgoingMessageBusService = netOutgoingMessageBusService ?? throw new ArgumentNullException(nameof(netOutgoingMessageBusService));
CurrentNetworkCommandServerTranslator = networkCommandServerTranslator ?? throw new ArgumentNullException(nameof(networkCommandServerTranslator));
GameStateRegistrar = gameStateService ?? throw new ArgumentNullException(nameof(gameStateService));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public NetworkCommandConnectionProducerService(
NetIncomingMessageBusService <TNetPeer> netIncomingMessageBusService,
IInputTranslator <NetIncomingMessage, NetworkCommandConnection> incomingMessageToNetworkCommandConnectionTranslator
)
{
if (incomingMessageToNetworkCommandConnectionTranslator == null)
{
throw new ArgumentNullException(nameof(incomingMessageToNetworkCommandConnectionTranslator));
}
IncomingMessageToNetworkCommandConnectionTranslator = incomingMessageToNetworkCommandConnectionTranslator;
if (netIncomingMessageBusService == null)
{
throw new ArgumentNullException(nameof(netIncomingMessageBusService));
}
NetIncomingMessageBusService = netIncomingMessageBusService;
}
/// <summary>
/// Creates a server object ( NetServer ) for interacting with clients
/// </summary>
/// <param name="serverPeerName">the peer name of the server</param>
/// <param name="serverIp">duh the ip OR what is not so plausible (the host name)</param>
/// <param name="serverPort">the server port</param>
private void CreateServer(string serverPeerName, string serverIp, int serverPort)
{
//net incoming message bus service creation
var serverPeerConfig = new NetPeerConfiguration(serverPeerName)
{
Port = serverPort,
AcceptIncomingConnections = true,
EnableUPnP = true,
LocalAddress = IPAddress.Parse(serverIp)
};
Server = new NetServer(serverPeerConfig);
ServerInput = new NetIncomingMessageBusService <NetServer>(Server);
ServerOutput = new NetOutgoingMessageBusService <NetServer>(Server, SerializationAdapter);
Server.Start();
Console.WriteLine(Server.ToString());
}
private void Initialize()
{
Client = new NetClient(
new NetPeerConfiguration(ClientConfiguration.ServerPeerName)
{
AcceptIncomingConnections = true,
EnableUPnP = true,
AutoFlushSendQueue = true
});
Client.Start();
Client.Connect(ClientConfiguration.ServerIp, ClientConfiguration.ServerPort);
var serializerType = GetSerializer(ClientConfiguration.SerializationAdapterType);
//var serializerType = ClientConfiguration.SerializationAdapterType.LoadType(true, false)?.FirstOrDefault();
SerializationAdapter = Activator.CreateInstance(serializerType) as ISerializationAdapter;
Input = new NetIncomingMessageBusService <NetClient>(Client);
Output = new NetOutgoingMessageBusService <NetClient>(Client, SerializationAdapter);
NetworkCommandDataConverterService = new NetworkCommandDataConverterService(SerializationAdapter);
NetIncomingMessageNetworkCommand = new NetIncomingMessageNetworkCommandConnectionTranslator(new NetworkCommandTranslator(SerializationAdapter));
}
private void Produce()
{
while (KeepProducing)
{
var messageChunk = NetIncomingMessageBusService.FetchMessageChunk();
if (messageChunk != null)
{
continue;
}
messageChunk.ToList().ForEach(message =>
{
var translatedMessage = IncomingMessageToNetworkCommandConnectionTranslator.Translate(message);
if (translatedMessage == null)
{
return;
}
NetworkCommandConnectionQueue.Value.Enqueue(translatedMessage);
});
}
}
