public override void FromBinaryReader(EndianBinaryReader reader)
{
PeerId = reader.ReadInt32();
RoomId = reader.ReadInt32();
Username = reader.ReadString();
CustomOptions = new DictionaryOptions(reader.ReadDictionary());
}
public override void FromBinaryReader(EndianBinaryReader reader)
{
MachineIp = reader.ReadString();
MaxProcesses = reader.ReadInt32();
Region = reader.ReadString();
CustomOptions = new DictionaryOptions(reader.ReadDictionary());
}
/// <summary>
/// This should be called from a process which is spawned.
/// For example, it can be called from a game server, which is started by the spawner
/// On successfull registration, callback contains <see cref="SpawnTaskController"/>, which
/// has a dictionary of properties, that were given when requesting a process to be spawned
/// </summary>
public void RegisterSpawnedProcess(int spawnId, string spawnCode, RegisterSpawnedProcessCallback callback, IClientSocket connection)
{
if (!connection.IsConnected)
{
callback.Invoke(null, "Not connected");
return;
}
var packet = new RegisterSpawnedProcessPacket()
{
SpawnCode = spawnCode,
SpawnId = spawnId
};
connection.SendMessage((short)MsfMessageCodes.RegisterSpawnedProcess, packet, (status, response) =>
{
if (status != ResponseStatus.Success)
{
callback.Invoke(null, response.AsString("Unknown Error"));
return;
}
// Read spawn task options received from master server
var options = new DictionaryOptions(new Dictionary <string, string>().FromBytes(response.AsBytes()));
// Create spawn task controller
var process = new SpawnTaskController(spawnId, options, connection);
callback.Invoke(process, null);
});
}
public void Append(DictionaryOptions options)
{
if (options != null)
{
Append(options.ToDictionary());
}
}
/// <summary>
/// Before we register our room we need to register spawned process if required
/// </summary>
protected void RegisterSpawnedProcess()
{
// Let's register this process
Msf.Server.Spawners.RegisterSpawnedProcess(Msf.Args.SpawnTaskId, Msf.Args.SpawnTaskUniqueCode, (taskController, error) =>
{
if (taskController == null)
{
logger.Error($"Room server process cannot be registered. The reason is: {error}");
return;
}
// Then start registering our room server
RegisterRoomServer(() =>
{
logger.Info("Finalizing registration task");
// Create finalization options
var options = new DictionaryOptions();
options.Add(MsfDictKeys.roomId, CurrentRoomController.RoomId);
// Send finilization request
taskController.FinalizeTask(options, () =>
{
logger.Info("Ok!");
OnRoomServerRegisteredEvent?.Invoke();
});
});
});
}
/// <summary>
/// Tries to get an access to a room with a given room id, password,
/// and some other <paramref name="customOptions"/>, which will be visible to the room (game server)
/// </summary>
/// <param name="roomId"></param>
/// <param name="password"></param>
/// <param name="customOptions"></param>
/// <param name="callback"></param>
/// <param name="connection"></param>
public void GetAccess(int roomId, string password, DictionaryOptions customOptions, RoomAccessCallback callback, IClientSocket connection)
{
if (!connection.IsConnected)
{
callback.Invoke(null, "Not connected");
return;
}
var roomAccessRequestPacket = new RoomAccessRequestPacket()
{
RoomId = roomId,
CustomOptions = customOptions,
Password = password
};
connection.SendMessage((short)MsfMessageCodes.GetRoomAccessRequest, roomAccessRequestPacket, (status, response) =>
{
if (status != ResponseStatus.Success)
{
callback.Invoke(null, response.AsString("Unknown Error"));
return;
}
var access = response.Deserialize(new RoomAccessPacket());
LastReceivedAccess = access;
callback.Invoke(access, null);
OnAccessReceivedEvent?.Invoke(access);
});
}
static Msf()
{
// Initialize helpers to work with MSF
Helper = new MsfHelper();
// Initialize advanced settings
Advanced = new MsfAdvancedSettings();
// Initialize runtime data
Runtime = new MsfRuntime();
// Initialize work with command line arguments
Args = new MsfArgs();
// List of options you can use in game
Options = new DictionaryOptions();
// Create a default connection
Connection = Advanced.ClientSocketFactory();
// Initialize parts of framework, that act as "clients"
Client = new MsfClient(Connection);
Server = new MsfServer(Connection);
Security = new MsfSecurity(Connection);
// Other stuff
Create = new MsfCreate();
Concurrency = new MsfConcurrency();
Events = new EventsChannel("default", true);
}
/// <summary>
/// This method should be called, when spawn process is finalized (finished spawning).
/// For example, when spawned game server fully starts
/// </summary>
public void FinalizeSpawnedProcess(int spawnId, DictionaryOptions finalizationData, CompleteSpawnedProcessCallback callback, IClientSocket connection)
{
if (!connection.IsConnected)
{
callback.Invoke(false, "Not connected");
return;
}
var packet = new SpawnFinalizationPacket()
{
SpawnTaskId = spawnId,
FinalizationData = finalizationData
};
connection.SendMessage((short)MsfMessageCodes.CompleteSpawnProcess, packet, (status, response) =>
{
if (status != ResponseStatus.Success)
{
callback.Invoke(false, response.AsString("Unknown Error"));
return;
}
callback.Invoke(true, null);
});
}
protected virtual DictionaryOptions GenerateOptions()
{
var options = new DictionaryOptions();
options.Set(Msf.Args.Names.LobbyId, Id.ToString());
return(options);
}
/// <summary>
/// Sends a login request, using given token
/// </summary>
public void SignIn(string token, SignInCallback callback, IClientSocket connection)
{
var credentials = new DictionaryOptions();
credentials.Add("token", token);
SignIn(credentials, callback, connection);
}
/// <summary>
/// Sends a request to server, to log in as a guest
/// </summary>
public void SignInAsGuest(SignInCallback callback, IClientSocket connection)
{
var credentials = new DictionaryOptions();
credentials.Add("guest", string.Empty);
SignIn(credentials, callback, connection);
}
public override void FromBinaryReader(EndianBinaryReader reader)
{
SpawnerId = reader.ReadInt32();
SpawnTaskId = reader.ReadInt32();
SpawnTaskUniqueCode = reader.ReadString();
OverrideExePath = reader.ReadString();
Options = new DictionaryOptions(reader.ReadDictionary());
CustomOptions = new DictionaryOptions(reader.ReadDictionary());
}
/// <summary>
/// Sends a login request, using given credentials
/// </summary>
public void SignIn(string username, string password, SignInCallback callback, IClientSocket connection)
{
var credentials = new DictionaryOptions();
credentials.Add("username", username);
credentials.Add("password", password);
SignIn(credentials, callback, connection);
}
public override void FromBinaryReader(EndianBinaryReader reader)
{
Token = reader.ReadString();
RoomIp = reader.ReadString();
RoomPort = reader.ReadInt32();
RoomId = reader.ReadInt32();
SceneName = reader.ReadString();
CustomOptions = new DictionaryOptions(reader.ReadDictionary());
}
/// <summary>
/// Create new <see cref="SpawnRequestController"/> instance
/// </summary>
/// <param name="spawnId"></param>
/// <param name="connection"></param>
/// <param name="spawnOptions"></param>
public SpawnRequestController(int spawnId, IClientSocket connection, DictionaryOptions spawnOptions)
{
this.connection = connection;
SpawnTaskId = spawnId;
SpawnOptions = spawnOptions;
// Set handlers
connection.SetHandler((short)MsfMessageCodes.SpawnRequestStatusChange, StatusUpdateHandler);
}
public override string ToString()
{
var options = new DictionaryOptions();
options.Add("Username", Username);
options.Add("PeerId", PeerId);
return(options.ToReadableString());
}
/// <summary>
/// Sends a generic login request
/// </summary>
public void SignIn(DictionaryOptions data, SignInCallback callback, IClientSocket connection)
{
Logs.Debug("Signing in...");
if (!connection.IsConnected)
{
callback.Invoke(null, "Not connected to server");
return;
}
IsNowSigningIn = true;
// We first need to get an aes key
// so that we can encrypt our login data
Msf.Security.GetAesKey(aesKey =>
{
if (aesKey == null)
{
IsNowSigningIn = false;
callback.Invoke(null, "Failed to log in due to security issues");
return;
}
var encryptedData = Msf.Security.EncryptAES(data.ToBytes(), aesKey);
connection.SendMessage((short)MsfMessageCodes.SignInRequest, encryptedData, (status, response) =>
{
IsNowSigningIn = false;
if (status != ResponseStatus.Success)
{
ClearAuthToken();
callback.Invoke(null, response.AsString("Unknown error"));
return;
}
AccountInfo = response.Deserialize(new AccountInfoPacket());
IsSignedIn = true;
if (RememberMe)
{
SaveAuthToken(AccountInfo.Token);
}
else
{
ClearAuthToken();
}
callback.Invoke(AccountInfo, null);
OnSignedInEvent?.Invoke();
});
}, connection);
}
public override string ToString()
{
var options = new DictionaryOptions();
options.Add("Product", Product);
options.Add("Version", Version);
options.Add("Comment", Comment);
options.Add("RawValue", RawValue);
return(options.ToReadableString());
}
public override string ToString()
{
var options = new DictionaryOptions();
options.Add("MachineIp", MachineIp);
options.Add("MaxProcesses", MaxProcesses);
options.Add("Region", string.IsNullOrEmpty(Region) ? "International" : Region);
options.Append(CustomOptions);
return(options.ToReadableString());
}
public override string ToString()
{
var options = new DictionaryOptions(Options);
if (options.IsValueEmpty(MsfDictKeys.region))
{
options.Set(MsfDictKeys.region, "International");
}
return(options.ToReadableString() + " " + CustomOptions.ToReadableString());
}
public SpawnTask(int spawnTaskId, RegisteredSpawner spawner, DictionaryOptions properties, DictionaryOptions customOptions)
{
Id = spawnTaskId;
Spawner = spawner;
Options = properties;
CustomOptions = customOptions;
UniqueCode = Msf.Helper.CreateRandomString(6);
whenDoneCallbacks = new List <Action <SpawnTask> >();
}
public GameInfoPacket()
{
Id = 0;
Address = string.Empty;
Name = string.Empty;
Region = string.Empty;
Type = GameInfoType.Unknown;
IsPasswordProtected = false;
MaxPlayers = 0;
OnlinePlayers = 0;
CustomOptions = new DictionaryOptions();
}
/// <summary>
/// Finalize spawn task
/// </summary>
/// <param name="finalizationData"></param>
/// <param name="callback"></param>
public void FinalizeTask(DictionaryOptions finalizationData, Action callback)
{
Msf.Server.Spawners.FinalizeSpawnedProcess(SpawnId, finalizationData, (successful, error) =>
{
if (error != null)
{
Logs.Error("Error while completing the spawn task: " + error);
}
callback.Invoke();
}, _connection);
}
public override void FromBinaryReader(EndianBinaryReader reader)
{
Name = reader.ReadString();
RoomIp = reader.ReadString();
RoomPort = reader.ReadInt32();
IsPublic = reader.ReadBoolean();
MaxConnections = reader.ReadInt32();
Password = reader.ReadString();
AccessTimeoutPeriod = reader.ReadSingle();
AllowUsersRequestAccess = reader.ReadBoolean();
Region = reader.ReadString();
CustomOptions = new DictionaryOptions(reader.ReadDictionary());
}
public override string ToString()
{
var options = new DictionaryOptions();
options.Add("RoomIp", RoomIp);
options.Add("RoomPort", RoomPort);
options.Add("RoomId", RoomId);
options.Add("Token", Token);
options.Add("SceneName", SceneName);
options.Append(CustomOptions);
return($"[Room Access Info: {options.ToReadableString()}]");
}
public override void FromBinaryReader(EndianBinaryReader reader)
{
Id = reader.ReadInt32();
Address = reader.ReadString();
Type = (GameInfoType)reader.ReadInt32();
Name = reader.ReadString();
Region = reader.ReadString();
IsPasswordProtected = reader.ReadBoolean();
MaxPlayers = reader.ReadInt32();
OnlinePlayers = reader.ReadInt32();
CustomOptions = new DictionaryOptions(reader.ReadDictionary());
}
public override string ToString()
{
var options = new DictionaryOptions();
options.Add("Username", Username);
options.Add("Email", Email);
options.Add("Token", Token);
options.Add("IsAdmin", IsAdmin);
options.Add("IsGuest", IsGuest);
options.Add("IsEmailConfirmed", IsEmailConfirmed);
options.Append(Properties);
return(options.ToReadableString());
}
/// <summary>
/// Start process on spawner side with given spawn <paramref name="options"/>, <paramref name="customOptions"/> and <paramref name="spawner"/>
/// </summary>
/// <param name="options"></param>
/// <param name="customOptions"></param>
/// <param name="spawner"></param>
/// <returns></returns>
public virtual SpawnTask Spawn(DictionaryOptions options, DictionaryOptions customOptions, RegisteredSpawner spawner)
{
// Create new spawn task
var task = new SpawnTask(GenerateSpawnTaskId(), spawner, options, customOptions);
// List this task
spawnTasksList[task.Id] = task;
// Add this task to queue
spawner.AddTaskToQueue(task);
logger.Debug("Spawner was found, and spawn task created: " + task);
return(task);
}
public override string ToString()
{
var options = new DictionaryOptions();
options.Add("RoomName", Name);
options.Add("RoomIp", RoomIp);
options.Add("RoomPort", RoomPort);
options.Add("MaxConnections", MaxConnections <= 0 ? "Unlimited" : MaxConnections.ToString());
options.Add("Use Password", !string.IsNullOrEmpty(Password));
options.Add("AccessTimeoutPeriod", $"{AccessTimeoutPeriod} sec.");
options.Add("AllowUsersRequestAccess", AllowUsersRequestAccess);
options.Add("Region", string.IsNullOrEmpty(Region) ? "International" : Region);
options.Append(CustomOptions);
return(options.ToReadableString());
}
public override string ToString()
{
string maxPleyers = MaxPlayers <= 0 ? "Unlimited" : MaxPlayers.ToString();
var options = new DictionaryOptions();
options.Add("Id", Id);
options.Add("Address", Address);
options.Add("Type", Type.ToString());
options.Add("Name", Name);
options.Add("Region", string.IsNullOrEmpty(Region) ? "International" : Region);
options.Add("IsPasswordProtected", IsPasswordProtected);
options.Add("MaxPlayers", maxPleyers);
options.Add("OnlinePlayers", $"{OnlinePlayers}/{maxPleyers}");
options.Append(CustomOptions);
return($"[GameInfo: {options.ToReadableString()}]");
}
