/// <summary>
/// Starts the server from the provided assembly
/// </summary>
/// <param name="assembly">The Uchu instance to start</param>
/// <param name="acceptConsoleCommands">Whether to handle console commands or not</param>
public async Task StartAsync(Assembly assembly, bool acceptConsoleCommands = false)
{
RegisterDefaultAssemblies(assembly);
if (acceptConsoleCommands)
{
StartConsole();
}
Running = true;
var server = RakNetServer.RunAsync();
var api = Api.StartAsync(ApiPort);
var tasks = new[]
{
server,
api
};
await Task.WhenAny(tasks).ConfigureAwait(false);
Console.WriteLine($"EXIT: {server.Status} | {api.Status}");
await StopAsync().ConfigureAwait(false);
}
public async Task ConfigureAsync(string configFile)
{
var serializer = new XmlSerializer(typeof(Configuration));
await using var fs = File.OpenRead(configFile);
Logger.Config = Config = (Configuration)serializer.Deserialize(fs);
if (!File.Exists(configFile))
{
throw new ArgumentException($"{configFile} config file does not exist.");
}
if (!string.IsNullOrWhiteSpace(Config.ResourcesConfiguration?.GameResourceFolder))
{
Resources = new LocalResources(Config);
}
ServerSpecification specification;
await using (var ctx = new NovaContext())
{
specification = await ctx.Specifications.FirstAsync(s => s.Id == Id);
}
Port = specification.Port;
_server = new RakNetServer(Port, "3.25 ND1");
}
/// <summary>
/// Shuts down the server
/// </summary>
public Task StopAsync()
{
Console.WriteLine(ResourceStrings.Server_StopAsync_Log);
Running = false;
ServerStopped?.Invoke();
Certificate?.Dispose();
Api?.Close();
return(RakNetServer.ShutdownAsync());
}
public Task StopAsync()
{
Logger.Log("Shutting down...");
Running = false;
ServerStopped?.Invoke();
Certificate.Dispose();
return(RakNetServer.ShutdownAsync());
}
public Task StopAsync()
{
Console.WriteLine("Shutting down...");
Running = false;
ServerStopped?.Invoke();
Certificate?.Dispose();
Api?.Close();
return(RakNetServer.ShutdownAsync());
}
public void HandleBatchPacket(RakNetSession session, byte[] buffer)
{
string id = RakNetServer.IPEndPointToID(session.EndPoint);
if (this.players.ContainsKey(id))
{
Player player = this.players[id];
int pkid = buffer[0];
if (pkid == BatchPacket.ID)
{
using (BatchPacket batch = new BatchPacket())
{
batch.SetBuffer(buffer);
batch.Decode();
this.GetPackets(batch, player);
}
}
}
}
public ServerStartWorkerEventArgs(RakNetServer server) : base(server)
{
}
public async Task HandlePacketAsync(IPEndPoint endPoint, byte[] data, Reliability reliability)
{
var connection = RakNetServer.GetConnection(endPoint);
await using var stream = new MemoryStream(data);
using var reader = new BitReader(stream);
var header = new PacketHeader();
reader.Read(header);
if (header.MessageId != MessageIdentifier.UserPacketEnum)
{
throw new ArgumentOutOfRangeException($"Packet is not {nameof(MessageIdentifier.UserPacketEnum)}");
}
if (header.PacketId == 0x05)
{
//
// Game Message
//
var objectId = reader.Read <long>();
var messageId = reader.Read <ushort>();
try
{
if (GameMessageReceived != null)
{
await GameMessageReceived(objectId, messageId, reader, connection).ConfigureAwait(false);
}
}
catch (Exception e)
{
Logger.Error(e);
}
return;
}
//
// Regular Packet
//
if (!HandlerMap.TryGetValue(header.RemoteConnectionType, out var temp) ||
!temp.TryGetValue(header.PacketId, out var handler))
{
Logger.Warning($"No handler registered for Packet ({header.RemoteConnectionType}:0x{header.PacketId:x})!");
return;
}
;
Logger.Debug($"Received {handler.Packet.GetType().FullName}");
reader.BaseStream.Position = 8;
try
{
reader.Read(handler.Packet);
await InvokeHandlerAsync(handler, connection).ConfigureAwait(false);
}
catch (Exception e)
{
Logger.Error(e);
}
}
public async Task StartAsync(Assembly assembly, bool acceptConsoleCommands = false)
{
Logger.Information("Registering assemblies...");
RegisterAssembly(typeof(Server).Assembly);
RegisterAssembly(assembly);
RakNetServer.MessageReceived += HandlePacketAsync;
Running = true;
if (acceptConsoleCommands)
{
var _ = Task.Run(async() =>
{
Logger.Information($"Ready to accept console command...");
while (Running)
{
var command = Console.ReadLine();
if (string.IsNullOrWhiteSpace(command))
{
continue;
}
Console.WriteLine(await HandleCommandAsync(command, null, GameMasterLevel.Console).ConfigureAwait(false));
}
});
}
try
{
Logger.Information("Looking for requests...");
await using (var ctx = new UchuContext())
{
var request = ctx.WorldServerRequests.FirstOrDefault(w => w.SpecificationId == Id);
if (request == default)
{
Logger.Information($"Starting server...");
await RakNetServer.RunAsync().ConfigureAwait(false);
return;
}
Logger.Information($"Request found for {Id}");
request.State = WorldServerRequestState.Complete;
ctx.SaveChanges();
}
Logger.Information($"Starting server...");
await RakNetServer.RunAsync().ConfigureAwait(false);
}
catch (Exception e)
{
Logger.Error(e);
}
}
public ServerDisconnectPeerEventArgs(RakNetServer server, RakNetPeer peer) : base(server)
{
Peer = peer;
}
public RakNetServerEventArgs(RakNetServer server)
{
Server = server;
}
public ServerPacketHandleEventArgs(RakNetServer server, RakNetPacket packet) : base(server)
{
Packet = packet;
}
public virtual void Connect(RakNetServer server)
{
Server = server;
}
private void Init()
{
this.server = new RakNetServer(MineNET.Server.ServerConfig.ServerPort);
this.RegisterPackets();
}
internal Connection(IPEndPoint endPoint, RakNetServer server)
{
EndPoint = endPoint;
_server = server;
}
