private INetWrapper CreateNetWrapper(string directory, string netDllPath, string host, ushort port)
{
INetWrapper netWrapper = new NetWrapper(directory, netDllPath, host, port);
RegisterNetWrapper(netWrapper);
return(netWrapper);
}
public MtaServer(
string directory,
string netDllPath,
Configuration?configuration = null,
Action <ServiceCollection>?dependencyCallback = null
)
{
this.configuration = configuration ?? new Configuration();
var validationResults = new List <ValidationResult>();
if (!Validator.TryValidateObject(this.configuration, new ValidationContext(this.configuration), validationResults, true))
{
string invalidProperties = string.Join("\r\n\t", validationResults.Select(r => r.ErrorMessage));
throw new Exception("An error has occurred while parsing configuration parameters:\r\n " + invalidProperties);
}
this.root = new RootElement();
this.serviceCollection = new ServiceCollection();
this.SetupDependencies(dependencyCallback);
this.serviceProvider = this.serviceCollection.BuildServiceProvider();
this.elementRepository = this.serviceProvider.GetRequiredService <IElementRepository>();
this.elementRepository.Add(this.root);
this.packetReducer = new PacketReducer();
this.clients = new Dictionary <NetWrapper, Dictionary <uint, Client> >();
this.netWrapper = CreateNetWrapper(directory, netDllPath, this.configuration.Host, this.configuration.Port);
}
public Client(uint binaryAddress, NetWrapper netWrapper)
{
this.binaryAddress = binaryAddress;
this.netWrapper = netWrapper;
this.Player = new Player(this);
this.IsConnected = true;
}
private void EnqueueIncomingPacket(NetWrapper netWrapper, uint binaryAddress, PacketId packetId, byte[] data)
{
if (!this.clients[netWrapper].ContainsKey(binaryAddress))
{
this.clients[netWrapper][binaryAddress] = new Client(binaryAddress, netWrapper);
}
this.packetReducer.EnqueuePacket(this.clients[netWrapper][binaryAddress], packetId, data);
}
private NetWrapper CreateNetWrapper(string directory, string netDllPath, string host, ushort port)
{
NetWrapper netWrapper = new NetWrapper(directory, netDllPath, host, port);
netWrapper.OnPacketReceived += EnqueueIncomingPacket;
this.clients[netWrapper] = new Dictionary <uint, Client>();
return(netWrapper);
}
private static void UpdatePlayers(List <NetConnection> recipients)
{
NetWrapper.SendMessage("PlayerInfo", msg => {
msg.Write((ushort)_players.Count);
foreach (var player in _players.Values)
{
msg.Write(player.ID);
}
}, recipients, NetDeliveryMethod.ReliableOrdered, 0);
}
public MtaServer(string directory, string netDllPath, string host, ushort port, IElementRepository elementRepository)
{
this.ElementRepository = elementRepository;
this.Root = new Element();
this.packetReducer = new PacketReducer();
this.clients = new Dictionary <NetWrapper, Dictionary <uint, Client> >();
this.netWrapper = CreateNetWrapper(directory, netDllPath, host, port);
}
public static void Main(string[] args)
{
NetMouseState testMS = NetMouseState.CreateTestNetMouseState();
NetWrapper testWrapper = new NetWrapper(Categories.NetMouseState, Originators.Observer, testMS);
Console.WriteLine(testWrapper.DebugText());
byte[] bytes = testWrapper.ToBytes();
foreach (byte b in bytes)
{
Console.Write(b + " ");
}
Console.Read();
}
private void EnqueueIncomingPacket(NetWrapper netWrapper, uint binaryAddress, PacketId packetId, byte[] data)
{
if (!this.clients[netWrapper].ContainsKey(binaryAddress))
{
this.clients[netWrapper][binaryAddress] = new Client(binaryAddress, netWrapper);
OnClientConnect?.Invoke(this.clients[netWrapper][binaryAddress]);
}
this.packetReducer.EnqueuePacket(this.clients[netWrapper][binaryAddress], packetId, data);
if (packetId == PacketId.PACKET_ID_PLAYER_QUIT || packetId == PacketId.PACKET_ID_PLAYER_TIMEOUT)
{
this.clients[netWrapper][binaryAddress].IsConnected = false;
OnClientDisconnect?.Invoke(this.clients[netWrapper][binaryAddress]);
this.clients[netWrapper].Remove(binaryAddress);
}
}
public void UpdatePlayerClient()
{
if (ClientList.Count < 1)
{
return;
}
NetworkStream playerStream = ClientList[0].GetStream();
MouseState cm = Mouse.GetState();
NetWrapper testPackage = new NetWrapper(Categories.NetMouseState, Originators.Server, new NetMouseState(cm));
playerStream.Write(testPackage.ToBytes(), 0, testPackage.Length);
playerStream.Flush();
System.Diagnostics.Debug.WriteLine("Data sent from server.");
}
private void ListenForComs()
{
if (CardServer.Properties.Settings.Default.Debug)
{
Console.WriteLine(ReceiveClientComThread.Name + " successfully started.");
}
NetworkStream clientStream = Client.GetStream();
byte[] byteBuffer = new byte[32];
int bufferFilledSize = 0;
int bytesRead;
while (Listening)
{
bytesRead = 0;
try
{
bufferFilledSize += bytesRead = clientStream.Read(byteBuffer, bufferFilledSize, 4); // read 4 bytes at a time.
}
catch (Exception e)
{
if (CardServer.Properties.Settings.Default.Debug)
{
Console.WriteLine(e.Message);
}
break;
}
if (bytesRead == 0)
{
break; // Connection timed out before any data was received.
}
}
if (bufferFilledSize > 0)
{
NetWrapper WrappedData = new NetWrapper(byteBuffer);
Server.MessageQueue.Enqueue(WrappedData);
}
Client.Close();
Server.ComReceivers.Remove(this);
}
public static int Main(String[] args)
{
Trace.Listeners.Add(new DebugListener());
_sTimer = new Stopwatch();
NetWrapper.RegisterMessageHandler("WorldInfo", msg => {
_sSkySeed = msg.ReadInt32();
_sRadius = msg.ReadFloat();
_sDensity = msg.ReadFloat();
_sTimerOffset = msg.ReadDouble() + NetWrapper.AverageRoundTripTime * 0.5;
_sMyID = msg.ReadUInt16();
_sTimer.Restart();
});
NetWrapper.RegisterMessageHandler("PlayerInfo", msg => {
var count = msg.ReadUInt16();
var players = new ushort[count];
for (int i = 0; i < count; ++i)
{
var id = players[i] = msg.ReadUInt16();
if (id != _sMyID && !_sPlayers.ContainsKey(id))
{
_sPlayers.Add(id, new PlayerInfo(id));
}
}
var removed = _sPlayers.Keys.Where(x => x == _sMyID || !players.Contains(x)).ToArray();
foreach (var id in removed)
{
_sPlayers.Remove(id);
}
});
NetWrapper.RegisterMessageHandler("PlayerPos", msg => {
var id = msg.ReadUInt16();
if (_sPlayers.ContainsKey(id))
{
var player = _sPlayers[id];
player.Position = new Vector3(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
}
});
_sSkySeed = 0;
_sMyID = 0xffff;
_sPlayers = new Dictionary <ushort, PlayerInfo>();
var qualities = new[] {
"Basic",
"FxAA",
"FxAA + Bloom"
};
Console.WriteLine("Select a display quality:");
for (int i = 0; i < qualities.Length; ++i)
{
Console.WriteLine("{0}. {1}", i + 1, qualities[i]);
}
while (!int.TryParse(Console.ReadKey(true).KeyChar.ToString(), out _sQuality) ||
_sQuality < 1 || _sQuality > qualities.Length)
{
;
}
_sQuality -= 1;
Console.WriteLine("Selected {0}", qualities[_sQuality]);
Console.WriteLine();
Console.Write("Server hostname [default localhost]: ");
var hostname = Console.ReadLine();
NetWrapper.Connect(hostname.Length > 0 ? hostname : "localhost", 14242);
NetWrapper.SendMessage("WorldInfo", NetDeliveryMethod.ReliableOrdered, 0);
while (_sSkySeed == 0)
{
if (!NetWrapper.CheckForMessages())
{
Thread.Sleep(16);
}
}
using (Toolkit.Init(new ToolkitOptions {
Backend = PlatformBackend.PreferNative
})) {
using (var app = new Program()) {
app.Run();
}
}
NetWrapper.Disconnect();
return(0);
}
protected override void OnUpdateFrame(FrameEventArgs e)
{
NetWrapper.CheckForMessages();
var move = Vector3.Zero;
if (Keyboard[Key.W])
{
move -= Vector3.UnitZ;
}
if (Keyboard[Key.S])
{
move += Vector3.UnitZ;
}
if (Keyboard[Key.A])
{
move -= Vector3.UnitX;
}
if (Keyboard[Key.D])
{
move += Vector3.UnitX;
}
if (Keyboard[Key.ControlLeft])
{
_camera.EyeHeight = CrouchEyeLevel;
}
else
{
_camera.EyeHeight += (StandEyeLevel - _camera.EyeHeight) * 0.25f;
}
if (_frameTimer.Elapsed.TotalSeconds > 0.5)
{
_frameTimer.Stop();
Title = String.Format("FPS: {0:F2}", _frameCounter / _frameTimer.Elapsed.TotalSeconds);
_frameTimer.Restart();
_frameCounter = 0;
}
if (move.LengthSquared > 0f)
{
var rot = Matrix4.CreateRotationY(-_camera.Yaw);
move = Vector3.Transform(move.Normalized(), rot);
if (Keyboard[Key.ControlLeft])
{
move *= 16f;
}
else if (Keyboard[Key.ShiftLeft])
{
move *= 48f;
}
else
{
move *= 24f;
}
if (_camera.Altitude > _camera.EyeHeight)
{
move *= 1f / 8f;
}
_camera.Push(move.Xz * (float)e.Time);
}
_camera.UpdateFrame(e);
foreach (var player in _sPlayers.Values)
{
player.UpdateFrame(e);
}
var pos = _camera.Position;
var period = _lastPosUpdateTimer.Elapsed.TotalSeconds;
if (period > 1.0 || (period > 1.0 / 30.0 && (_oldPos - pos).Length > 1f / 16f))
{
NetWrapper.SendMessage("PlayerPos", msg => {
msg.Write(pos.X);
msg.Write(pos.Y);
msg.Write(pos.Z);
}, NetDeliveryMethod.ReliableSequenced, 1);
_oldPos = pos;
_lastPosUpdateTimer.Restart();
}
}
public static int Main(String[] args)
{
Console.Write("Sky seed [default random]: ");
var seedStr = Console.ReadLine();
if (seedStr.Length == 0)
{
seedStr = "0";
}
int seed;
if (!int.TryParse(seedStr, out seed))
{
seed = seedStr.GetHashCode();
}
if (seed == 0)
{
seed = new Random().Next(1, int.MaxValue);
}
float radius = 0f;
float density = 0f;
do
{
Console.Write("World radius <0.5 - 1024> [default 8]: ");
var str = Console.ReadLine();
if (str.Length == 0)
{
radius = 8f;
}
else
{
float.TryParse(str, out radius);
}
} while (radius < 0.5f || radius > 1024f);
do
{
Console.Write("World density <1 - 65536> [default 1024]: ");
var str = Console.ReadLine();
if (str.Length == 0)
{
density = 1024f;
}
else
{
float.TryParse(str, out density);
}
} while (density < 1f || density > 65536f);
_skySeed = seed;
_players = new Dictionary <NetConnection, PlayerInfo>();
var timer = new Stopwatch();
timer.Start();
NetWrapper.RegisterIdentifier("PlayerInfo");
NetWrapper.RegisterMessageHandler("WorldInfo", msg => {
var player = GetPlayer(msg.SenderConnection);
NetWrapper.SendMessage("WorldInfo", reply => {
reply.Write(_skySeed);
reply.Write(radius);
reply.Write(density);
reply.Write(timer.Elapsed.TotalSeconds);
reply.Write(player.ID);
}, msg.SenderConnection, NetDeliveryMethod.ReliableOrdered, 0);
});
NetWrapper.RegisterMessageHandler("PlayerPos", msg => {
var player = GetPlayer(msg.SenderConnection);
player.Position = new Vector3(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
var others = NetWrapper.Connections;
others.Remove(msg.SenderConnection);
NetWrapper.SendMessage("PlayerPos", reply => {
reply.Write(player.ID);
reply.Write(player.Position.X);
reply.Write(player.Position.Y);
reply.Write(player.Position.Z);
}, others, NetDeliveryMethod.ReliableSequenced, 1);
});
NetWrapper.StartListening(14242, 128);
while (NetWrapper.Status != NetPeerStatus.NotRunning)
{
if (!NetWrapper.CheckForMessages())
{
Thread.Sleep(16);
}
var connected = NetWrapper.Connections;
var disconnected = _players.Values.Where(x => !connected.Contains(x.Connection)).ToArray();
if (disconnected.Length > 0)
{
foreach (var player in disconnected)
{
_players.Remove(player.Connection);
}
UpdatePlayers(connected);
}
}
return(0);
}
/// <summary>
/// Adds a new NetWrapper object to the SendingActions queue.
/// </summary>
/// <param name="netObject">Payload data to wrap and add to the SendingActions queue.</param>
public void EnqueueSend(Payload netObject)
{
NetWrapper action = new NetWrapper(Categories.NetMouseState, Originator, netObject);
SendingActions.Enqueue(action);
}
internal Client(uint binaryAddress, NetWrapper netWrapper) : base()
{
this.binaryAddress = binaryAddress;
this.netWrapper = netWrapper;
}
