/// <summary>
/// extension of writeline function
/// </summary>
/// <param name="f">
/// </param>
/// <param name="message">
/// </param>
/// <param name="color">
/// </param>
/// <param name="showTimeTag">
/// shows time on output
/// </param>
public static void WriteLine(this Form f, string message = null, Color?color = null, bool showTimeTag = false)
{
FConsole console = CheckFConsole(f);
message = message ?? "";
console.WriteLine(message, color, showTimeTag);
}
/// <summary>
/// extension of readline
/// </summary>
/// <returns>
/// </returns>
public static async Task <string> ReadLine(this Form f)
{
FConsole console = CheckFConsole(f);
var line = await console.ReadLine();
return(line);
}
/// <summary>
/// extension of write function
/// </summary>
/// <param name="f">
/// </param>
/// <param name="message">
/// </param>
/// <param name="color">
/// </param>
public static void Write(this Form f, string message = null, Color?color = null)
{
FConsole console = CheckFConsole(f);
message = message ?? "";
console.Write(message, color, false);
}
public static void Process(User user, byte[] buffer)
{
var msgUser = (MsgUser)buffer;
FConsole.WriteLine($"MsgUser Deserializing & Processing took {((((float)PacketRouter.Stopwatch.ElapsedTicks) / Stopwatch.Frequency) * 1000000):0} microsec");
}
public static void Handle(byte[] buffer)
{
var packetId = BitConverter.ToUInt16(buffer, 4);
if (Global.Verbose)
{
FConsole.WriteLine($"Got Packet {packetId}");
}
switch (packetId)
{
case 1000:
Login.Handle(buffer);
break;
case 1001:
Walk.Handle(buffer);
break;
case 1002:
Ping.Handle(buffer);
break;
case 1003:
Spawn.Handle(buffer);
break;
}
ArrayPool <byte> .Shared.Return(buffer);
}
public static void Main()
{
FConsole.LogToFile = false;
FConsole.WriteLine("PID: " + Process.GetCurrentProcess().Id);
FConsole.WriteLine("Current Root: " + Environment.CurrentDirectory);
FConsole.WriteLine("Setting Thread Priority to highest...");
Thread.CurrentThread.Priority = ThreadPriority.Highest;
FConsole.WriteLine("Initializing the engine...");
var engine = new Engine(false)
{
IsFixedTimeStep = false
};
FConsole.WriteLine("Initializing the scene...");
var testScene = new TestingScene
{
Id = 1
};
SceneManager.Initialize(engine.Content);
SceneManager.ActivateScene(testScene);
FConsole.WriteLine("Initializing scene systems...");
FConsole.WriteLine("Running game...");
engine.Run();
}
public void Disconnect(string reason)
{
FConsole.WriteLine("Disconnecting: " + reason);
IsConnected = false;
Socket?.Dispose();
OnDisconnect?.Invoke();
}
public void ConnectAsync(string host, ushort port)
{
var ipList = Dns.GetHostAddresses(host).Where(i => i.AddressFamily == AddressFamily.InterNetwork).ToArray();
var endPoint = new IPEndPoint(ipList.First(), port);
if (IsConnected)
{
Disconnect("ClientSocket.ConnectAsync() IsConnected == true");
}
FConsole.WriteLine($"Connecting to {host} at {ipList.First()} on port {port}");
try
{
var connectArgs = new SocketAsyncEventArgs();
connectArgs.Completed += Completed;
connectArgs.UserToken = this;
connectArgs.RemoteEndPoint = endPoint;
if (!Socket.ConnectAsync(connectArgs))
{
Completed(null, connectArgs);
}
}
catch (Exception ex)
{
Disconnect($"ClientSocket.ConnectAsync() if (!Socket.ConnectAsync(connectArgs)) -> {ex.Message} {ex.StackTrace}");
}
}
public static void Process(byte[] buffer)
{
var msgUser = (MsgUser)buffer;
var user = new User
{
Id = msgUser.UniqueId
};
if (user.Id == Core.MyUser.Id)
{
Core.MyUser.Name = msgUser.GetNickname();
Core.MyUser.AvatarUrl = msgUser.GetAvatarUrl();
Core.MyUser.Online = true;
Core.MyUser.Servers[0].IconUrl = msgUser.GetAvatarUrl();
}
else
{
user.Name = msgUser.GetNickname();
user.AvatarUrl = msgUser.GetAvatarUrl();
user.Online = msgUser.Online;
if (msgUser.ServerId == 0)
{
Core.MyUser.Friends.TryAdd(user.Id, user);
Core.MyUser.Servers[msgUser.ServerId].Channels.Add(user.Id, new Channel(user.Id, user.Name));
}
else
{
var server = Core.MyUser.GetServer(msgUser.ServerId);
server?.AddUser(user);
}
FConsole.WriteLine($"Received Friend info for {user.Name}!");
}
FConsole.WriteLine($"MsgUser: {PacketRouter.Stopwatch.Elapsed.TotalMilliseconds:0.0000}ms");
}
public static void Process(byte[] buffer)
{
var msgVServer = (MsgVServer)buffer;
var server = new VirtualServer
{
Id = msgVServer.UniqueId,
Name = msgVServer.GetServerName(),
IconUrl = msgVServer.GetServerIconUrl()
};
Core.MyUser.Servers.TryAdd(server.Id, server);
Dispatcher.UIThread.InvokeAsync(async() =>
{
await Task.Delay(3000);
(MainWindow.Instance.DataContext as HomeViewModel)?.Servers.Add(server);
});
if (Core.SelectedServer == null)
{
Core.SelectedServer = server;
}
FConsole.WriteLine($"Received Server info for {server.Name}!");
FConsole.WriteLine($"MsgVServer: {PacketRouter.Stopwatch.Elapsed.TotalMilliseconds:0.0000}ms");
}
public static void Main()
{
FConsole.Title = "SERVER APP";
GlobalExceptionHandler.Setup();
Jit.PreJit();
Core.Db = new JsonDb();
Core.Db.EnsureDbReady();
ReceiveQueue.OnPacket += PacketRouter.Route;
ServerSocket.Start(Core.Settings.Port);
FConsole.WriteLine("Online");
while (true)
{
var cmd = FConsole.ReadLine();
switch (cmd)
{
case "exit":
Core.Db.Save();
Environment.Exit(0);
break;
default:
break;
}
}
}
public void Update(GameTime deltaTime)
{
World.Update();
for (int i = 0; i < World.Systems.Count; i++)
{
var preUpdateTicks = DateTime.UtcNow.Ticks;
var system = World.Systems[i];
if (!system.WantsUpdate)
{
continue;
}
if (system.IsActive)
{
if (Global.Verbose)
{
FConsole.WriteLine("Update Starting for " + system.Name);
}
system.Update((float)deltaTime.ElapsedGameTime.TotalSeconds);
if (Global.Verbose)
{
FConsole.WriteLine("Done " + system.Name);
}
}
var postUpdateTicks = DateTime.UtcNow.Ticks;
Profiler.AddUpdate(system.Name, (postUpdateTicks - preUpdateTicks) / 10000f);
}
}
public static void Process(byte[] buffer)
{
var msgUser = (MsgUser)buffer;
var user = new User
{
Id = msgUser.UniqueId
};
if (user.Id == Core.MyUser.Id)
{
Core.MyUser.Name = msgUser.GetNickname();
Core.MyUser.AvatarUrl = msgUser.GetAvatarUrl();
Core.MyUser.Online = true;
Core.MyUser.Servers[0].IconUrl = msgUser.GetAvatarUrl();
}
else
{
user.Name = msgUser.GetNickname();
user.AvatarUrl = msgUser.GetAvatarUrl();
user.Online = msgUser.Online;
if (msgUser.ServerId == 0)
{
Core.MyUser.Friends.TryAdd(user.Id, user);
Core.MyUser.Servers[msgUser.ServerId].Channels.Add(user.Id, new Channel(user.Id, user.Name));
}
else
{
var server = Core.MyUser.GetServer(msgUser.ServerId);
server?.AddUser(user);
}
FConsole.WriteLine($"Received Friend info for {user.Name}!");
}
FConsole.WriteLine($"MsgUser Deserializing & Processing took {(((float)PacketRouter.Stopwatch.ElapsedTicks) / Stopwatch.Frequency) * 1000000000} ns");
}
/// <summary>
/// extension of read key
/// </summary>
/// <returns>
/// </returns>
public static async Task <char> ReadKey(this Form f, Color?color = null)
{
FConsole console = CheckFConsole(f);
var line = await console.ReadKey(color);
return(line);
}
internal static void Received(object sender, SocketAsyncEventArgs e)
{
var token = (ClientSocket)e.UserToken;
if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
{
try
{
ReceiveQueue.Add(e);
token.ReceiveSync.WaitOne();
if (!token.Socket.ReceiveAsync(e))
{
Received(null, e);
}
}
catch (Exception exception)
{
FConsole.WriteLine(exception);
CloseClientSocket(e);
}
}
else
{
CloseClientSocket(e);
}
}
public static void Process(User user, byte[] buffer)
{
var msgChannel = (MsgChannel)buffer;
FConsole.WriteLine($"Received Server info for {msgChannel.GetName()}!");
FConsole.WriteLine($"MsgChannel Deserializing & Processing took {((((float)PacketRouter.Stopwatch.ElapsedTicks) / Stopwatch.Frequency) * 1000000):0} microsec");
}
private static void Connected()
{
FConsole.WriteLine("Socket Connected! Logging in...");
Client.Diffie = new DiffieHellman(256).GenerateRequest();
var msgDh = MsgDH.Create(Client.Diffie.ToString());
Client.Send(msgDh);
}
private void Disconnected()
{
FConsole.WriteLine("Disconnected!");
Socket.OnConnected -= Connected;
Socket.OnDisconnect -= Disconnected;
Socket?.Socket?.Dispose();
Thread.Sleep(5000);
ConnectAsync(User, Pass);
}
private static void Disconnected()
{
Thread.Sleep(1000);
FConsole.WriteLine("Socket disconnected!");
Client = new ClientSocket(ushort.MaxValue);
Client.OnConnected += Connected;
Client.OnDisconnect += Disconnected;
Client.ConnectAsync(ServerHostname, ServerPort);
}
public static async Task PopulateMenu()
{
PopulateBase();
await Task.Run(() =>
{
if (string.IsNullOrEmpty(Properties.Settings.Default.PakPath))
{
Application.Current.Dispatcher.Invoke(delegate
{
var launcher = new FLauncher();
if ((bool)launcher.ShowDialog())
{
Properties.Settings.Default.PakPath = launcher.Path;
Properties.Settings.Default.Save();
}
});
}
// define the current game thank to the pak path
Folders.SetGameName(Properties.Settings.Default.PakPath);
// Add Pak Files
if (Directory.Exists(Properties.Settings.Default.PakPath))
{
string[] paks = Directory.GetFiles(Properties.Settings.Default.PakPath, "*.pak");
for (int i = 0; i < paks.Length; i++)
{
if (!Utils.Paks.IsFileReadLocked(new FileInfo(paks[i])))
{
PakFileReader pakFile = new PakFileReader(paks[i]);
DebugHelper.WriteLine("{0} {1} {2} {3}", "[FModel]", "[PAK]", "[Registering]", $"{pakFile.FileName} with GUID {pakFile.Info.EncryptionKeyGuid.Hex}");
if (i == 0)
{
Globals.Game.Version = pakFile.Info.Version;
Globals.Game.SubVersion = pakFile.Info.SubVersion;
}
Application.Current.Dispatcher.Invoke(delegate
{
MenuItems.pakFiles.Add(new PakMenuItemViewModel
{
PakFile = pakFile,
IsEnabled = false
});
});
}
else
{
FConsole.AppendText(string.Format(Properties.Resources.PakFileLocked, Path.GetFileNameWithoutExtension(paks[i])), FColors.Red, true);
DebugHelper.WriteLine("{0} {1} {2} {3}", "[FModel]", "[PAK]", "[Locked]", paks[i]);
}
}
}
});
}
public static void Process(MsgDataRequest msgDataRequest)
{
switch (msgDataRequest.Type)
{
case MsgDataRequestType.Friends:
{
FConsole.WriteLine("Stage Completed: Sync Friendlist");
foreach (var friend in Core.MyUser.Friends)
{
var request = MsgDataRequest.CreateRequestMissedMessagesPacket(Core.MyUser.Id, friend.Key);
Core.Client.Send(request);
}
var request2 = MsgDataRequest.CreateServerListRequest(Core.MyUser.Id);
Core.Client.Send(request2);
break;
}
case MsgDataRequestType.VServers:
{
FConsole.WriteLine("Stage Completed: Sync VServers");
foreach (var server in Core.MyUser.Servers)
{
var request = MsgDataRequest.CreateServerChannelListRequest(Core.MyUser.Id, server.Key);
Core.Client.Send(request);
}
Core.MyUser.Servers.TryAdd(0, VirtualServer.CreateDMServer(Core.MyUser));
Core.SelectedServer = Core.MyUser.Servers[0];
Core.SelectedChannel = Core.MyUser.Servers[0].Channels.Values.FirstOrDefault();
break;
}
case MsgDataRequestType.Channels:
FConsole.WriteLine("Stage Completed: Sync Channels of " + Core.MyUser.Servers[msgDataRequest.TargetId].Name);
foreach (var server in Core.MyUser.Servers.Values)
{
foreach (var channel in server.Channels)
{
var request = MsgDataRequest.CreateRequestMissedMessagesPacket(Core.MyUser.Id, server.Id, channel.Key);
Core.Client.Send(request);
}
}
break;
case MsgDataRequestType.Messages:
FConsole.WriteLine("Stage Completed: Sync Messages of " + Core.MyUser.Servers[msgDataRequest.TargetId].Channels[msgDataRequest.Param].Name);
break;
default:
FConsole.WriteLine("Invalid stage.");
break;
}
FConsole.WriteLine($"MsgDataRequest: {PacketRouter.Stopwatch.Elapsed.TotalMilliseconds:0.0000}ms");
}
public UObject(IoPackageReader reader, string type, bool structFallback = false)
{
Dict = new Dictionary <string, object>();
var header = new FUnversionedHeader(reader);
if (header.HasValues)
{
using var it = new FIterator(header);
if (header.HasNonZeroValues)
{
FUnversionedType unversionedType = reader.GetOrCreateSchema(type);
var num = 1;
do
{
var(val, isNonZero) = it.Current;
if (unversionedType.Properties.TryGetValue(val, out var props))
{
var propertyTag = new FPropertyTag(props);
if (isNonZero)
{
var key = Dict.ContainsKey(props.Name) ? $"{props.Name}_NK{num++:00}" : props.Name;
var obj = BaseProperty.ReadAsObject(reader, propertyTag, propertyTag.Type, ReadType.NORMAL);
Dict[key] = obj;
}
else
{
var key = Dict.ContainsKey(props.Name) ? $"{props.Name}_NK{num++:00}" : props.Name;
var obj = BaseProperty.ReadAsZeroObject(reader, propertyTag, propertyTag.Type);
Dict[key] = obj;
}
}
else
{
Dict[val.ToString()] = null;
}
} while (it.MoveNext());
}
else
{
#if DEBUG
FConsole.AppendText(string.Concat("\n", type ?? "Unknown", ": ", reader.Summary.Name.String), "#CA6C6C", true);
do
{
FConsole.AppendText($"Val: {it.Current.Val} (IsNonZero: {it.Current.IsNonZero})", FColors.Yellow, true);
}while (it.MoveNext());
#endif
}
}
if (!structFallback && reader.ReadInt32() != 0 /* && reader.Position + 16 <= maxSize*/)
{
reader.Position += FGuid.SIZE;
}
}
public static void Process(User user, byte[] buffer)
{
var msgVServer = (MsgVServer)buffer;
var server = new VirtualServer();
server.Id = msgVServer.UniqueId;
server.Name = msgVServer.GetServerName();
server.IconUrl = msgVServer.GetServerIconUrl();
FConsole.WriteLine($"Received Server info for {server.Name}!");
FConsole.WriteLine($"MsgVServer Deserializing & Processing took {((((float)PacketRouter.Stopwatch.ElapsedTicks) / Stopwatch.Frequency) * 1000000):0} microsec");
}
public void Disconnect(string reason)
{
try
{
FConsole.WriteLine("Disconnecting: " + reason);
IsConnected = false;
}
finally
{
OnDisconnect?.Invoke();
}
}
static void Main()
{
GlobalExceptionHandler.Setup();
FConsole.WriteLine("Hello World!");
ServerSocket.OnPacket += PacketRouter.Handle;
ServerSocket.Start(65533);
while (true)
{
Console.ReadLine();
}
}
public static async Task Main()
{
FConsole.WriteLine("Host: ");
ServerHostname = Console.ReadLine().Trim();
Client.OnConnected += Connected;
Client.OnPacket += PacketRouter.Handle;
Client.OnDisconnect += Disconnected;
Client.ConnectAsync(ServerHostname, ServerPort);
while (true)
{
var msg = Console.ReadLine();
switch (msg)
{
case "login":
Client.Send(MsgLogin.Create("asd", "asdasd", true, MsgLoginType.Login));
break;
case "ping":
var array = new byte[MsgBench.MAX_ARRAY_LENGTH];
var random = new Random();
for (var i = 0; i < array.Length; i++)
{
array[i] = (byte)random.Next(0, 255);
}
Stopwatch.Start();
for (var i = 0; i < 1000; i++)
{
var msgBench = MsgBench.Create(array, false);
Client.Send(msgBench);
}
break;
case "send":
var user = (User)Client.StateObject;
FConsole.WriteLine("Requesting Token...");
user.Send(MsgToken.Create("transcoder", 0, true));
while (!user.Tokens.ContainsKey(0))
{
Thread.Sleep(1);
}
FConsole.WriteLine("Uploading... using " + user.Tokens[0]);
Stopwatch.Start();
await user.SendFile(@"/home/alumni/transcoder", 0);
Stopwatch.Stop();
FConsole.WriteLine($"Done. {Stopwatch.Elapsed.TotalSeconds.ToString("##.##")}");
break;
}
}
}
public byte[] Get()
{
if (_queue.IsEmpty)
{
Fill();
}
if (_queue.TryDequeue(out var buffer))
{
return(buffer);
}
FConsole.WriteLine("F*****g queue starved.");
return(new byte[320]);
}
public static void Load(string path)
{
FConsole.WriteLine("Loading " + Environment.CurrentDirectory + "/" + path);
var iniFile = new IniFile(path);
iniFile.Load();
var contents = iniFile.GetDictionary();
var textureName = "Name= not set in [Atlas]";
var tileSize = 0;
foreach (var header in contents)
{
var name = header.Key[1..^ 1];
public static void Handle(byte[] buffer)
{
var msgPing = (MsgPing)buffer;
if (msgPing.Ping == 0)
{
NetworkSystem.Send(msgPing);
}
else
{
FConsole.WriteLine("[Net][MsgPing] Ping: " + msgPing.Ping);
}
}
private static void Log(string path, FileStream filestream)
{
var count = 0;
double size = filestream.Position;
while (size > 1000)
{
size = size / 1024;
count++;
}
FConsole.WriteLine($"File {path} -> {filestream.Position} bytes written ({size.ToString("###.##")} {(FormatEnum)count}) received!");
Streams.TryRemove(path, out _);
filestream.Dispose();
}
