/// <summary> /// Retrieves a list of public games, which pass a provided filter. /// (You can implement your own filtering by extending modules or "classes" /// that implement <see cref="IGamesProvider"/>) /// </summary> public void FindGames(MstProperties filter, FindGamesCallback callback, IClientSocket connection) { if (!connection.IsConnected) { Games = new List <GameInfoPacket>(); Logs.Error("Not connected"); callback.Invoke(Games); return; } connection.SendMessage((short)MstMessageCodes.FindGamesRequest, filter.ToBytes(), (status, response) => { if (status != ResponseStatus.Success) { Games = new List <GameInfoPacket>(); Logs.Error(response.AsString("Unknown error while requesting a list of games")); callback.Invoke(Games); return; } Games = response.DeserializeList(() => new GameInfoPacket()).ToList(); callback.Invoke(Games); }); }
public UpdateAccountPropertiesPacket() { UserId = string.Empty; Properties = new MstProperties(); }
/// <summary> /// Sends a request to create a lobby, using a specified factory /// </summary> public void CreateLobby(string factory, MstProperties options, CreateLobbyCallback calback) { CreateLobby(factory, options, calback, Connection); }
/// <summary> /// Set's lobby user properties (current player sets his own properties, /// which can be accessed by game server and etc.) /// </summary> /// <param name="properties"></param> /// <param name="callback"></param> public void SetMyProperties(MstProperties properties, SuccessCallback callback) { SetMyProperties(properties, callback, Connection); }
/// <summary> /// Sends a generic login request /// </summary> public void SignIn(MstProperties 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 Mst.Security.GetAesKey(aesKey => { if (aesKey == null) { IsNowSigningIn = false; callback.Invoke(null, "Failed to log in due to security issues"); return; } var encryptedData = Mst.Security.EncryptAES(data.ToBytes(), aesKey); connection.SendMessage((short)MstMessageCodes.SignIn, encryptedData, (status, response) => { IsNowSigningIn = false; if (status != ResponseStatus.Success) { ClearAuthToken(); callback.Invoke(null, response.AsString("Unknown error")); return; } // Parse account info var accountInfoPacket = response.Deserialize(new AccountInfoPacket()); AccountInfo = new ClientAccountInfo() { Id = accountInfoPacket.Id, Username = accountInfoPacket.Username, Email = accountInfoPacket.Email, PhoneNumber = accountInfoPacket.PhoneNumber, Facebook = accountInfoPacket.Facebook, Token = accountInfoPacket.Token, IsAdmin = accountInfoPacket.IsAdmin, IsGuest = accountInfoPacket.IsGuest, IsEmailConfirmed = accountInfoPacket.IsEmailConfirmed, Properties = accountInfoPacket.Properties, }; // If RememberMe is checked on and we are not guset, then save auth token if (RememberMe && !AccountInfo.IsGuest && !string.IsNullOrEmpty(AccountInfo.Token)) { SaveAuthToken(AccountInfo.Token); } else { ClearAuthToken(); } IsSignedIn = true; callback.Invoke(AccountInfo, null); OnSignedInEvent?.Invoke(); }); }, connection); }
/// <summary> /// Sends a registration request to server /// </summary> /// <param name="data"></param> /// <param name="callback"></param> public void SignUp(MstProperties data, SuccessCallback callback) { SignUp(data, callback, Connection); }
/// <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="callback"></param> /// <param name="password"></param> /// <param name="customOptions"></param> public void GetAccess(int roomId, string password, MstProperties customOptions, RoomAccessCallback callback) { GetAccess(roomId, password, customOptions, callback, Connection); }
/// <summary> /// Sends a request to room, to retrieve an access to it for a specified peer, /// with some extra options /// </summary> /// <param name="peer"></param> /// <param name="customOptions"></param> /// <param name="callback"></param> public void GetAccess(IPeer peer, MstProperties customOptions, GetAccessCallback callback) { // If request is already pending if (requestsInProgress.Contains(peer.Id)) { callback.Invoke(null, "You've already requested an access to this room"); return; } // If player is already in the game if (connectedPlayers.ContainsKey(peer.Id)) { callback.Invoke(null, "You are already in this room"); return; } // If player has already received an access and didn't claim it // but is requesting again - send him the old one var currentAccess = unconfirmedAccesses.Values.FirstOrDefault(v => v.Peer == peer); if (currentAccess != null) { // Restore the timeout currentAccess.Timeout = DateTime.Now.AddSeconds(Options.AccessTimeoutPeriod); callback.Invoke(currentAccess.Access, null); return; } // If there's a player limit if (Options.MaxConnections != 0) { var playerSlotsTaken = requestsInProgress.Count + accessesInUse.Count + unconfirmedAccesses.Count; if (playerSlotsTaken >= Options.MaxConnections) { callback.Invoke(null, "Room is already full"); return; } } // Create packet to request checking of access var provideRoomAccessCheckPacket = new ProvideRoomAccessCheckPacket() { PeerId = peer.Id, RoomId = RoomId, CustomOptions = customOptions }; // Try to find out if requester is logged in add the username if available // Simetimes we want to check if user is banned var userPeerExtension = peer.GetExtension<IUserPeerExtension>(); if (userPeerExtension != null && !string.IsNullOrEmpty(userPeerExtension.Username)) { provideRoomAccessCheckPacket.Username = userPeerExtension.Username; } // Add requester peer id to pending list to prevent new access request to this room requestsInProgress.Add(peer.Id); // Send request to owner of the room to get access token Peer.SendMessage((short)MstMessageCodes.ProvideRoomAccessCheck, provideRoomAccessCheckPacket, (status, response) => { // Remove requester peer id from pending list requestsInProgress.Remove(peer.Id); if (status != ResponseStatus.Success) { callback.Invoke(null, response.AsString("Unknown Error")); return; } // Parse access data from message var accessData = response.Deserialize(new RoomAccessPacket()); // Create new access info var access = new RoomAccessData() { Access = accessData, Peer = peer, Timeout = DateTime.Now.AddSeconds(Options.AccessTimeoutPeriod) }; // Save the access info to list and wait for confirmation unconfirmedAccesses[access.Access.Token] = access; callback.Invoke(access.Access, null); }); }
/// <summary> /// Returns list of properties of public room /// </summary> /// <param name="player"></param> /// <param name="room"></param> /// <param name="playerFilters"></param> /// <returns></returns> public virtual MstProperties GetPublicRoomOptions(IPeer player, RegisteredRoom room, MstProperties playerFilters) { return(room.Options.CustomOptions); }
/// <summary> /// Default spawn spawned process request handler that will be used by controller if <see cref="spawnRequestHandler"/> is not overriden /// </summary> /// <param name="data"></param> /// <param name="message"></param> public virtual void SpawnRequestHandler(SpawnRequestPacket data, IIncomingMessage message) { Logger.Debug($"Default spawn handler started handling a request to spawn process for spawn controller [{SpawnerId}]"); /************************************************************************/ // Create process args string var processArguments = new MstProperties(); /************************************************************************/ // Check if we're overriding an IP to master server var masterIpArgument = string.IsNullOrEmpty(SpawnSettings.MasterIp) ? Connection.ConnectionIp : SpawnSettings.MasterIp; // Create master IP arg processArguments.Set(Mst.Args.Names.MasterIp, masterIpArgument); /************************************************************************/ /// Check if we're overriding a port to master server var masterPortArgument = SpawnSettings.MasterPort < 0 ? Connection.ConnectionPort : SpawnSettings.MasterPort; // Create master port arg processArguments.Set(Mst.Args.Names.MasterPort, masterPortArgument); /************************************************************************/ // Machine Ip processArguments.Set(Mst.Args.Names.RoomIp, SpawnSettings.MachineIp); /************************************************************************/ // Create port for room arg int machinePortArgument = Mst.Server.Spawners.GetAvailablePort(); processArguments.Set(Mst.Args.Names.RoomPort, machinePortArgument); /************************************************************************/ // Room Name //processArguments.Set(Mst.Args.Names.RoomName, $"\"{data.Options.AsString(MstDictKeys.roomName, "Room_" + Mst.Helper.CreateRandomString(6))}\""); /************************************************************************/ // Room Region //processArguments.Set(Mst.Args.Names.RoomRegion, $"\"{SpawnSettings.Region}\""); /************************************************************************/ // Room Max Connections //if (data.Options.Has(MstDictKeys.maxPlayers)) //{ // processArguments.Set(Mst.Args.Names.RoomMaxConnections, data.Options.AsString(MstDictKeys.maxPlayers)); //} /************************************************************************/ // Get the scene name //if (data.Options.Has(MstDictKeys.sceneName)) //{ // processArguments.Set(Mst.Args.Names.LoadScene, data.Options.AsString(MstDictKeys.sceneName)); //} /************************************************************************/ // Create use websockets arg //if (SpawnSettings.UseWebSockets) //{ // processArguments.Set(Mst.Args.Names.UseWebSockets, string.Empty); //} /************************************************************************/ // Create spawn id arg processArguments.Set(Mst.Args.Names.SpawnTaskId, data.SpawnTaskId); /************************************************************************/ // Create spawn code arg processArguments.Set(Mst.Args.Names.SpawnTaskUniqueCode, data.SpawnTaskUniqueCode); /************************************************************************/ // Create custom args processArguments.Append(data.CustomOptions); /************************************************************************/ // Path to executable var executablePath = SpawnSettings.ExecutablePath; if (string.IsNullOrEmpty(executablePath)) { executablePath = File.Exists(Environment.GetCommandLineArgs()[0]) ? Environment.GetCommandLineArgs()[0] : Process.GetCurrentProcess().MainModule.FileName; } // In case a path is provided with the request if (data.Options.Has(MstDictKeys.ROOM_EXE_PATH)) { executablePath = data.Options.AsString(MstDictKeys.ROOM_EXE_PATH); } if (!string.IsNullOrEmpty(data.OverrideExePath)) { executablePath = data.OverrideExePath; } /// Create info about starting process var startProcessInfo = new ProcessStartInfo(executablePath) { CreateNoWindow = false, UseShellExecute = true, Arguments = processArguments.ToReadableString(" ", " ") }; Logger.Debug("Starting process with args: " + startProcessInfo.Arguments); var processStarted = false; try { new Thread(() => { try { using (var process = Process.Start(startProcessInfo)) { Logger.Debug("Process started. Spawn Id: " + data.SpawnTaskId + ", pid: " + process.Id); processStarted = true; lock (processLock) { // Save the process processes[data.SpawnTaskId] = process; } var processId = process.Id; // Notify server that we've successfully handled the request MstTimer.RunInMainThread(() => { message.Respond(ResponseStatus.Success); NotifyProcessStarted(data.SpawnTaskId, processId, startProcessInfo.Arguments); }); process.WaitForExit(); } } catch (Exception e) { if (!processStarted) { MstTimer.RunInMainThread(() => { message.Respond(ResponseStatus.Failed); }); } Logger.Error("An exception was thrown while starting a process. Make sure that you have set a correct build path. " + $"We've tried to start a process at [{executablePath}]. You can change it at 'SpawnerBehaviour' component"); Logger.Error(e); } finally { lock (processLock) { // Remove the process processes.Remove(data.SpawnTaskId); } MstTimer.RunInMainThread(() => { // Release the port number Mst.Server.Spawners.ReleasePort(machinePortArgument); Logger.Debug($"Notifying about killed process with spawn id [{data.SpawnTaskId}]"); NotifyProcessKilled(data.SpawnTaskId); }); } }).Start(); } catch (Exception e) { message.Respond(e.Message, ResponseStatus.Error); Logs.Error(e); } }
public override void FromBinaryReader(EndianBinaryReader reader) { RoomId = reader.ReadInt32(); Password = reader.ReadString(); CustomOptions = new MstProperties(reader.ReadDictionary()); }
public override void FromBinaryReader(EndianBinaryReader reader) { Options = new MstProperties(reader.ReadDictionary()); CustomOptions = new MstProperties(reader.ReadDictionary()); }
public ClientsSpawnRequestPacket() { Options = new MstProperties(); CustomOptions = new MstProperties(); }
public override void FromBinaryReader(EndianBinaryReader reader) { UserId = reader.ReadString(); Properties = new MstProperties(reader.ReadDictionary()); }
public UpdateAccountPropertiesPacket(string userId, MstProperties properties) { UserId = userId ?? throw new ArgumentNullException(nameof(userId)); Properties = properties ?? throw new ArgumentNullException(nameof(properties)); }
/// <summary> /// Adds new or updates existing options /// </summary> /// <param name="options"></param> /// <returns></returns> public bool AddOrUpdate(MstProperties options) { return(AddOrUpdate(options.ToDictionary())); }
/// <summary> /// Append options to this list /// </summary> /// <param name="options"></param> public MstProperties Append(MstProperties options) { return(Append(options.ToDictionary())); }
public SpawnTask(int spawnTaskId, RegisteredSpawner spawner, MstProperties options, MstProperties customOptions) { Id = spawnTaskId; Spawner = spawner; Options = options; CustomOptions = customOptions; UniqueCode = Mst.Helper.CreateRandomAlphanumericString(6); whenDoneCallbacks = new List <Action <SpawnTask> >(); }
/// <summary> /// Tries to get an access to a room with a given room id /// and some other <paramref name="customOptions"/>, which will be visible to the room (game server) /// </summary> /// <param name="roomId"></param> /// <param name="callback"></param> /// <param name="customOptions"></param> public void GetAccess(int roomId, RoomAccessCallback callback, MstProperties customOptions) { GetAccess(roomId, "", customOptions, callback, Connection); }
public LobbyMember(string username, LobbyUserPeerExtension ext) { Username = username; Extension = ext; Properties = new MstProperties(); }
/// <summary> /// Set's current player's properties /// </summary> public void SetMyProperties(MstProperties properties, SuccessCallback callback) { Mst.Client.Lobbies.SetMyProperties(properties, callback, _connection); }
/// <summary> /// Sends a request to master server, to spawn a process with given options /// </summary> /// <param name="options"></param> public void RequestSpawn(MstProperties options) { RequestSpawn(options, new MstProperties(), string.Empty, null, Connection); }
/// <summary> /// Sends a generic login request /// </summary> /// <param name="data"></param> /// <param name="callback"></param> public void SignIn(MstProperties data, SignInCallback callback) { SignIn(data, callback, Connection); }
/// <summary> /// Sends a request to master server, to spawn a process in a given region, and with given options /// </summary> /// <param name="options"></param> public void RequestSpawn(MstProperties options, string region) { RequestSpawn(options, new MstProperties(), region, null, Connection); }
/// <summary> /// Sets lobby properties of a specified lobby id /// </summary> /// <param name="lobbyId"></param> /// <param name="properties"></param> /// <param name="callback"></param> public void SetLobbyProperties(int lobbyId, MstProperties properties, SuccessCallback callback) { SetLobbyProperties(lobbyId, properties, callback, Connection); }
/// <summary> /// Sends a request to master server, to spawn a process in a given region, and with given options /// </summary> /// <param name="options"></param> /// <param name="region"></param> /// <param name="callback"></param> public void RequestSpawn(MstProperties options, MstProperties customOptions, string region, SpawnRequestResultHandler callback) { RequestSpawn(options, customOptions, region, callback, Connection); }
/// <summary> /// Set's lobby user properties (current player sets his own properties, /// which can be accessed by game server and etc.) /// </summary> public void SetMyProperties(MstProperties properties, SuccessCallback callback, IClientSocket connection) { connection.SendMessage((short)MstMessageCodes.SetMyLobbyProperties, properties.ToBytes(), Mst.Create.SuccessCallback(callback)); }
public virtual MstProperties GetPublicLobbyProperties(IPeer peer, ILobby lobby, MstProperties playerFilters) { return(lobby.GetPublicProperties(peer)); }
public SpawnerOptions() { CustomOptions = new MstProperties(); }
/// <summary> /// Instance of room server peer extension /// </summary> /// <param name="masterPeerId"></param> /// <param name="username"></param> /// <param name="roomPeer"></param> /// <param name="customOptions"></param> public RoomPlayerPeerExtension(int masterPeerId, string username, IPeer roomPeer, MstProperties customOptions) { MasterPeerId = masterPeerId; Username = username ?? throw new ArgumentNullException(nameof(username)); Peer = roomPeer ?? throw new ArgumentNullException(nameof(roomPeer)); Properties = customOptions ?? throw new ArgumentNullException(nameof(customOptions)); }