/// <summary>
    /// Event triggered to perform the matchmaking algorithm
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnFindParticipants_Click(object sender, EventArgs e)
    {
        int studyID = Convert.ToInt32(Request.QueryString["study_id"]);
        Matchmaker matchmaker = new Matchmaker(new Study(studyID));
        Table tblResults = new Table();
        TableHeaderRow header = new TableHeaderRow();
        TableHeaderCell headerName = new TableHeaderCell();
        TableHeaderCell headerEmail = new TableHeaderCell();
        TableHeaderCell headerScore = new TableHeaderCell();
        headerName.Text = "Name";
        headerEmail.Text = "Email";
        headerScore.Text = "Score";
        header.Cells.Add(headerName);
        header.Cells.Add(headerEmail);
        header.Cells.Add(headerScore);
        tblResults.Rows.Add(header);
        tblResults.CellSpacing = 3;
        tblResults.CellPadding = 5;

        foreach (KeyValuePair<Participant, int> result in matchmaker.Results) {
            TableRow row = new TableRow();
            TableCell cellID = new TableCell();
            TableCell cellName = new TableCell();
            TableCell cellEmail = new TableCell();
            TableCell cellScore = new TableCell();

            cellID.Text = result.Key.UserID.ToString();
            cellID.Visible = false;
            HyperLink link = new HyperLink();
            link.ToolTip = "Click the link to view more information about this user";
            link.Text = result.Key.FirstName + " " + result.Key.LastName;
            link.NavigateUrl="ParticipantInfo.aspx?participant_id=" + cellID.Text + "&study_id=" + studyID;
            cellName.Controls.Add(link);
            cellEmail.Text = result.Key.Email;
            cellScore.Text = result.Value.ToString();

            row.Cells.Add(cellID);
            row.Cells.Add(cellName);
            row.Cells.Add(cellEmail);
            row.Cells.Add(cellScore);
            tblResults.Rows.AddAt(getIndexToAdd(tblResults, row), row);
            pnlmatchmakingResults.Controls.Add(tblResults);
        }

        if (matchmaker.Results.Count == 0) {
            lblNoResults.Visible = true;
        }

        pnlmatchmakingResults.Visible = true;
        btnEmailParticipant.Visible = true;
    }
        public static decimal CalculatePoints(Set playerSet)
        {
            decimal alphaPowerAverage = playerSet.AlphaTeam.Players.Select(e => e.PowerLevel).Average();
            decimal bravoPowerAverage = playerSet.BravoTeam.Players.Select(e => e.PowerLevel).Average();

            decimal points;

            switch (playerSet.Winning)
            {
            case Set.WinningTeam.Tie:
                points = 1;
                break;

            case Set.WinningTeam.Bravo:
            {
                points = (decimal)(200F * playerSet.BravoTeam.Score /
                                   ((7 * playerSet.AlphaTeam.Score / playerSet.MatchNum + 4) *
                                    (1 + Math.Pow(10, (double)((bravoPowerAverage - alphaPowerAverage) / 200))) * 4));

                break;
            }

            case Set.WinningTeam.Alpha:
            {
                points = (decimal)(200F * playerSet.AlphaTeam.Score /
                                   ((7 * playerSet.BravoTeam.Score / playerSet.MatchNum + 4) *
                                    (1 + Math.Pow(10, (double)((alphaPowerAverage - bravoPowerAverage) / 200))) * 4));
                break;
            }

            default:
                throw new ArgumentOutOfRangeException();
            }

            points /=
                (int)Matchmaker.GetClass(playerSet.AllPlayers.OrderBy(x => x.PowerLevel).First().PowerLevel) -
                (int)Matchmaker.GetClass(playerSet.AllPlayers.OrderByDescending(x => x.PowerLevel).First().PowerLevel)
                + 1;

            //TimePeriod happyPeriod = new TimePeriod(TimeSpan.Parse("20:00"), TimeSpan.Parse("21:00"));
            //if (happyPeriod.IsWithinPeriod(playerSet.StartTime.GetValueOrDefault()))
            //{
            //    points *= 2;
            //}

            return(points);
        }
Exemplo n.º 3
0
 void UpdateMatchmakingUI()
 {
     if (m_UseMatchmaking && MatchmakingServer.Length > 0)
     {
         GUILayout.Label("Matchmaking");
         GUILayout.Label("Finding a server...");
         if (GUILayout.Button("Cancel"))
         {
             m_Matchmaker     = null;
             m_UseMatchmaking = false;
         }
     }
     else
     {
         m_UseMatchmaking = false;
     }
 }
Exemplo n.º 4
0
	//public MySecondScript secondScriptqqqqqqwe;

	void Awake()
	{
		Debug.Log ("Awake");
		myMatchMaker = new Matchmaker();
		myPeople = new MyPeople();
		int lastYear = 0;
		currentYear = 0;

		Person Adam = new Person(Person.PersonType.Adam, currentYear.ToString());
		Person Eve = new Person(Person.PersonType.Eve, currentYear.ToString());
		var personAIndex = myPeople.addToAllPeople(Adam);
		var personEIndex = myPeople.addToAllPeople(Eve);
		myMatchMaker.addToSinglesList(personAIndex, Adam.Sex);
		myMatchMaker.addToSinglesList(personEIndex, Eve.Sex);

		//Debug.Log ("Hello " + Adam.Name + " and " + Eve.Name + " !");
		//Debug.Log (Adam.GetSex() + " and " + Eve.GetSex());

		/// TODO
		/// implement the House cluster Display List Data type
		/// Draw a sample Cluster
		/// put in Marriage portals
		/// put in tomb stones
		/// add in Divorce and side winds
		/// 
		for (currentYear = 0 ; currentYear < 200 ; currentYear++)
		{

			Debug.Log ("Happy New Year!!.  It is year: " + currentYear.ToString());
			Debug.Log ("We have " + myMatchMaker.BachelorPersonIndexList.Count + " Bachelors, and " +
			           myMatchMaker.BachelorettePersonIndexList.Count + " Bachelorettes");
			Debug.Log ("Our people count is " + myPeople.allPeople.Count + ", with alive count =" + myPeople.livingCount());
			Debug.Log ("We have " + myMatchMaker.allFamilies.Count + " Families <-----------------------");

			myMatchMaker.doWeddings(currentYear);
			myMatchMaker.beFruitfullAndMultiply(currentYear);
			myPeople.mortality(currentYear);

			lastYear = currentYear;
		}
		Debug.Log("We are done with populating the earth!");

		myMatchMaker.displayAllFamilies(lastYear);

	}
        public override void DoActions(ref Client client)
        {
            switch (PacketType)
            {
            case PacketType.c_StartingMatchmaking:
                var matchmaker = Matchmaker.GetInstance();
                matchmaker.JoinMatchmakingQueue(client);
                break;

            case PacketType.c_StoppingMatchmaking:
                throw new NotImplementedException();
                break;

            default:
                Trace.WriteLine(string.Format("[MatchmakingPacketHandler.DoActions] - " +
                                              "Invalid packet type for this PacketHandler = {0}", PacketType.ToString()));
                break;
            }
        }
        void EndMatchmaking()
        {
            // Headless only supports 1 mm attempt, so if we end/abort, we're done
            m_HeadlessShouldMatchmake = false;

            // Clean up existing matchmaker
            if (m_Matchmaker != null)
            {
                m_LastMatchmakingState = m_Matchmaker.State;

                // See if we need to cancel an existing matchmaking request
                if (!m_Matchmaker.Done)
                {
                    // TODO: Add cancel functionality when matchmaking client library is updated with it
                }
            }

            m_Matchmaker = null;
        }
Exemplo n.º 7
0
        public void TestSingleMatchmadeGame()
        {
            Client client1 = clientManager.GetClientFromEmailAddress("TestUser1");
            Client client2 = clientManager.GetClientFromEmailAddress("TestUser2");
            Client client3 = clientManager.GetClientFromEmailAddress("TestUser3");
            Client client4 = clientManager.GetClientFromEmailAddress("TestUser4");

            var matchmaker = Matchmaker.GetInstance();

            matchmaker.JoinMatchmakingQueue(client1);
            matchmaker.JoinMatchmakingQueue(client2);
            matchmaker.JoinMatchmakingQueue(client3);
            matchmaker.JoinMatchmakingQueue(client4);

            // Slightly more than one interval.
            Thread.Sleep(11000);

            var roomManager = RoomManager.GetInstance();

            var clientList = roomManager.GetRoomMembers(client1);
            Assert.AreEqual(clientList.Count, 4);
        }
Exemplo n.º 8
0
        public void TestMatchmakingTimeOut()
        {
            Client client1 = clientManager.GetClientFromEmailAddress("TestUser1");
            Client client2 = clientManager.GetClientFromEmailAddress("TestUser2");
            Client client3 = clientManager.GetClientFromEmailAddress("TestUser3");
            Client client4 = clientManager.GetClientFromEmailAddress("TestUser4");

            var matchmaker = Matchmaker.GetInstance();

            matchmaker.JoinMatchmakingQueue(client1);

            Thread.Sleep(matchmaker.MaxClientWaitTime + 1000);

            matchmaker.JoinMatchmakingQueue(client2);
            matchmaker.JoinMatchmakingQueue(client3);
            matchmaker.JoinMatchmakingQueue(client4);

            var roomManager = RoomManager.GetInstance();

            var clientList = roomManager.GetRoomMembers(client1);

            Assert.AreEqual(clientList.Count, 1);
        }
Exemplo n.º 9
0
 public WomanMatchmakerMediator(Matchmaker man, Matchmaker woman)
 {
     m_man   = man;
     m_woman = woman;
 }
Exemplo n.º 10
0
        public async Task <IActionResult> OnGetAsync(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            Tournament = await _context.Tournament
                         .FirstOrDefaultAsync(m => m.Id == id);

            if (Tournament == null)
            {
                return(NotFound());
            }

            var organizer = await _identity.Users
                            .Select(u => new { u.Id, Name = $"{u.FirstName} {u.LastName}" })
                            .FirstOrDefaultAsync(m => m.Id == Tournament.Organizer);

            if (organizer == null)
            {
                return(NotFound());
            }

            Organizer = organizer.Name;

            SponsorLogoUrls = await _context.Sponsor
                              .Where(s => s.TournamentId == Tournament.Id)
                              .Select(s => s.LogoUrl)
                              .ToListAsync();

            Participants = await _context.Participant
                           .Where(p => p.TournamentId == Tournament.Id)
                           .CountAsync();

            CanApply = !(await _context.Participant
                         .Where(p => p.TournamentId == id && p.UserId == _userManager.GetUserId(User))
                         .AnyAsync());

            if (Participants >= Tournament.MaxParticipants || Tournament.ApplicationDeadline <= DateTime.Now)
            {
                CanApply = false;
            }

            if (Tournament.Time <= DateTime.Now && !Tournament.Ongoing)
            {
                Task matchmaking = null;
                lock (Locker)
                {
                    var check = _context.Tournament
                                .Where(t => t.Id == Tournament.Id)
                                .Select(t => t.Ongoing)
                                .First();
                    if (!check)
                    {
                        Tournament.Ongoing = true;
                        _context.SaveChanges();
                        var matchmaker = new Matchmaker(_context, Tournament);
                        matchmaking = matchmaker.LaunchTournament();
                    }
                }

                if (matchmaking != null)
                {
                    await matchmaking;
                }
            }

            return(Page());
        }
Exemplo n.º 11
0
        private async Task JoinLobby(CommandContext ctx, SdlPlayer sdlPlayer, bool debugFill = false, int?lobbyNumber = null)
        {
            try
            {
                Lobby matchedLobby;

                if (lobbyNumber != null)
                {
                    LobbySelectResponse lobbySelectResponse = Matchmaker.SelectLobbyByNumber(sdlPlayer, lobbyNumber.Value);

                    if (!lobbySelectResponse.Success)
                    {
                        if (lobbySelectResponse.Exception != null)
                        {
                            Logger.Error(lobbySelectResponse.Exception);
                        }

                        if (!string.IsNullOrEmpty(lobbySelectResponse.Message))
                        {
                            await ctx.RespondAsync(lobbySelectResponse.Message);
                        }

                        return;
                    }

                    matchedLobby = lobbySelectResponse.Result;

                    if (!string.IsNullOrEmpty(lobbySelectResponse.Message))
                    {
                        await ctx.RespondAsync(lobbySelectResponse.Message);
                    }
                }
                else
                {
                    LobbySelectResponse lobbySelectResponse = Matchmaker.FindLobby(sdlPlayer);

                    if (!lobbySelectResponse.Success)
                    {
                        if (lobbySelectResponse.Exception != null)
                        {
                            Logger.Error(lobbySelectResponse.Exception);
                        }

                        if (!string.IsNullOrEmpty(lobbySelectResponse.Message))
                        {
                            await ctx.RespondAsync(lobbySelectResponse.Message);
                        }

                        return;
                    }

                    if (!string.IsNullOrEmpty(lobbySelectResponse.Message))
                    {
                        await ctx.RespondAsync(lobbySelectResponse.Message);
                    }

                    matchedLobby = lobbySelectResponse.Result;
                }

                matchedLobby.AddPlayer(sdlPlayer);

                if (debugFill)
                {
                    foreach (SdlPlayer nextPlayer in (await MySqlClient.RetrieveAllSdlPlayers()).Where(e => e != sdlPlayer).Take(7))
                    {
                        matchedLobby.AddPlayer(nextPlayer, true);
                    }
                }

                if (matchedLobby.IsFull)
                {
                    MoveToSetResponse moveToSetResponse = Matchmaker.MoveLobbyToSet(matchedLobby);

                    if (!moveToSetResponse.Success)
                    {
                        if (moveToSetResponse.Exception != null)
                        {
                            Logger.Error(moveToSetResponse.Exception);
                        }

                        if (moveToSetResponse.Message != null)
                        {
                            await ctx.RespondAsync(moveToSetResponse.Message,
                                                   embed : matchedLobby.GetEmbedBuilder().Build());
                        }

                        return;
                    }

                    if (!string.IsNullOrEmpty(moveToSetResponse.Message))
                    {
                        await ctx.RespondAsync(moveToSetResponse.Message);
                    }

                    Set newSet = moveToSetResponse.Result;
                    newSet.Closed += this.NewMatch_Closed;

                    DiscordRole setRole =
                        ctx.Guild.Roles.First(e => e.Name == $"In Set ({newSet.SetNumber})");

                    foreach (SdlPlayer setPlayer in newSet.AllPlayers)
                    {
                        DiscordMember member = await ctx.Guild.GetMemberAsync(setPlayer.DiscordId);

                        await member.GrantRoleAsync(setRole);
                    }

                    DiscordChannel setChannel = await CommandHelper.ChannelFromSet(newSet.SetNumber);

                    await ctx.RespondAsync($"Lobby filled! Please move to {setChannel.Mention}.");

                    await ctx.Guild.UpdateRoleAsync(setRole, mentionable : true);

                    DiscordMessage lastMessage = await setChannel.SendMessageAsync(
                        $"{setRole.Mention} Welcome to set #{newSet.SetNumber}! To begin, " +
                        $"{(await ctx.Guild.GetMemberAsync(newSet.BravoTeam.Captain.DiscordId)).Mention} will have " +
                        $"one minute to pick a player using `%pick [player]`.",
                        embed : newSet.GetEmbedBuilder().Build());

                    await ctx.Guild.UpdateRoleAsync(setRole, mentionable : false);

                    newSet.DraftTimeout += NewSet_DraftTimeout;
                    newSet.ResetTimeout();
                }
                else
                {
                    string message =
                        $"{sdlPlayer.DiscordId.ToUserMention()} has been added to " +
                        $"Lobby #{matchedLobby.LobbyNumber}. {8 - matchedLobby.Players.Count} players needed to begin.";

                    DiscordRole classOneRole   = ctx.Guild.GetRole(600770643075661824);
                    DiscordRole classTwoRole   = ctx.Guild.GetRole(600770814521901076);
                    DiscordRole classThreeRole = ctx.Guild.GetRole(600770862307606542);
                    DiscordRole classFourRole  = ctx.Guild.GetRole(600770905282576406);

                    DiscordRole[] notifRoles = { classOneRole, classTwoRole, classThreeRole, classFourRole };

                    if (matchedLobby.Players.Count == 1)
                    {
                        matchedLobby.DeltaUpdated += MatchedLobby_DeltaUpdated;

                        message = $"{notifRoles[(int)matchedLobby.Class - 1].Mention} " +
                                  $"{((int)matchedLobby.Class - 2 > 0 ? notifRoles[(int)matchedLobby.Class - 2].Mention + " " : "")}" +
                                  $"A new lobby has been started! {message}";
                    }

                    DiscordEmbedBuilder builder = matchedLobby.GetEmbedBuilder();

                    await ctx.RespondAsync(message, false, builder.Build());
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Logger.Error(e);
                throw;
            }
        }
Exemplo n.º 12
0
 public void Init()
 {
     TradeQueue.Instance.Clear();
     maker = new Matchmaker();
 }
Exemplo n.º 13
0
        static void Main(string[] args)
        {
            // string accessToken = KeyVaultHelper.GetSecret(bearerTokenIdentifier);

            // var storageAccount = AzureStorageHelper.CreateStorageAccountFromConnectionString(connectionString);

            CloudTable table = AzureStorageHelper.GetOrCreateTableAsync("partyCodes").Result;

            // AzureStorageHelper.DeleteParty("WXYZ", table);

            // AzureStorageHelper.InsertOrMergeParty(new Party("IYEY"), table);
            // AzureStorageHelper.InsertAccessTokenToParty("WXYZ", table, accessTokenA);

            var accessTokens = AzureStorageHelper.GetParty("WXYZ", table).GetAccessTokens();

            var topArtists = new List <IEnumerable <Artist> >();

            foreach (var token in accessTokens)
            {
                topArtists.Add(SpotifyHelper.GetTopArtistsAsync(token).Result);
            }

            var commonArtists = Matchmaker.FindCommonArtists(topArtists.ElementAt(0), topArtists.ElementAt(1));
            var commonGenres  = Matchmaker.FindCommonGenres(topArtists.ElementAt(0), topArtists.ElementAt(1));

            var difference = topArtists.ElementAt(0).Except(commonArtists);

            ;

            // var topArtistsA = SpotifyHelper.GetTopArtistsAsync(accessTokenA, "short_term").Result;
            // var topArtistsB = SpotifyHelper.GetTopArtistsAsync(accessTokenB, "short_term").Result;
            // ;
            // // var userA = SpotifyHelper.GetUserAsync(accessTokenA).Result;
            // // var userB = SpotifyHelper.GetUserAsync(accessTokenB).Result;

            // // SpotifyHelper.CreatePlaylistAsync(accessToken, user.Id).Wait();

            // var commonArtists = SpotifyHelper.FindCommonArtists(topArtistsA, topArtistsB);

            // var commonGenres = SpotifyHelper.FindCommonGenres(topArtistsA, topArtistsB);

            // var commonArtistsString = String.Join(", ", commonArtists);

            // var commonGenresString = string.Join(", ", commonGenres);

            // Console.WriteLine($"You have these artists in common: {commonArtistsString}");

            // Console.WriteLine($"You have these genres in common: {commonGenresString}");

            // var suggestedArtists = SpotifyHelper.SuggestArtists(topArtistsA, topArtistsB);
            // var suggestedArtistsString = String.Join(", ", suggestedArtists);
            // Console.WriteLine($"We suggest listening to these artists: {suggestedArtistsString}");

            // var artistIDs = SpotifyHelper.SuggestArtistIDs(topArtistsA, topArtistsB).ToList();

            var playListId = SpotifyHelper.CreatePlaylistAsync(accessTokens[0], "Spotify Matchmaker Playlist").Result;

            foreach (var artist in commonArtists)
            {
                var tracks = SpotifyHelper.GetArtistsTopTracksAsync(accessTokens[0], artist).Result;
                SpotifyHelper.AddSongsToPlaylistAsync(accessTokens[0], playListId, tracks);
            }

            ;
        }
        private static async Task Client_ReactionAdded(MessageReactionAddEventArgs messageReactionAddEventArgs)
        {
            DiscordChannel channel = messageReactionAddEventArgs.Channel;

            try
            {
                if (channel.Id == 595219144488648704)
                {
                    DiscordMessage newUserMessage = await channel.GetMessageAsync(messageReactionAddEventArgs.Message.Id);

                    DiscordChannel registeredChannel = await Client.GetChannelAsync(588806681303973931);

                    if (!File.Exists(Path.Combine(Globals.AppPath, "Registrations", $"{newUserMessage.Id}")))
                    {
                        return;
                    }

                    if (newUserMessage.Reactions.FirstOrDefault(e => e.Emoji.Name == "\u2705")?.Count > 1)
                    {
                        string[] allRegLines = await File.ReadAllLinesAsync(Path.Combine(Globals.AppPath,
                                                                                         "Registrations",
                                                                                         $"{newUserMessage.Id}"));

                        ulong userId = Convert.ToUInt64(allRegLines[0]);

                        const decimal powerLevel = 2000;
                        await MySqlClient.RegisterPlayer(userId, 2000, allRegLines[1]);

                        const int classNum = 2;

                        DiscordGuild guild = await Client.GetGuildAsync(570743985530863649);

                        DiscordMember registeredUser = await guild.GetMemberAsync(userId);

                        await registeredUser.SendMessageAsync(
                            $"You have been approved! You have been placed in class {classNum}. " +
                            $"To jump into a set, head into #draft and use %join.");

                        await registeredUser.GrantRoleAsync(guild.GetRole(572537013949956105));


                        DiscordRole classOneRole   = guild.GetRole(600770643075661824);
                        DiscordRole classTwoRole   = guild.GetRole(600770814521901076);
                        DiscordRole classThreeRole = guild.GetRole(600770862307606542);
                        DiscordRole classFourRole  = guild.GetRole(600770905282576406);

                        try
                        {
                            switch (Matchmaker.GetClass(powerLevel))
                            {
                            case SdlClass.Zero:
                                break;

                            case SdlClass.One:
                                if (registeredUser.Roles.All(e => e.Id != classOneRole.Id))
                                {
                                    await registeredUser.GrantRoleAsync(classOneRole);
                                }

                                break;

                            case SdlClass.Two:
                                if (registeredUser.Roles.All(e => e.Id != classTwoRole.Id))
                                {
                                    await registeredUser.GrantRoleAsync(classTwoRole);
                                }

                                break;

                            case SdlClass.Three:
                                if (registeredUser.Roles.All(e => e.Id != classThreeRole.Id))
                                {
                                    await registeredUser.GrantRoleAsync(classThreeRole);
                                }

                                break;

                            case SdlClass.Four:
                                if (registeredUser.Roles.All(e => e.Id != classFourRole.Id))
                                {
                                    await registeredUser.GrantRoleAsync(classFourRole);
                                }

                                break;

                            default:
                                throw new ArgumentOutOfRangeException();
                            }
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);
                        }

                        File.Delete(Path.Combine(Globals.AppPath, "Registrations", $"{newUserMessage.Id}"));

                        DiscordEmbed registrationEmbed = newUserMessage.Embeds.First();

                        DiscordEmbedBuilder builder = new DiscordEmbedBuilder
                        {
                            Description =
                                $"**User {registeredUser.Mention} ({registeredUser.Username}#{registeredUser.Discriminator}) has been approved!**"
                        };

                        builder.AddField(e =>
                        {
                            e.Name     = "Class";
                            e.Value    = $"{classNum}";
                            e.IsInline = false;
                        });

                        builder.WithFields(registrationEmbed.Fields.Select(e =>
                        {
                            DiscordFieldBuilder builderSelect = new DiscordFieldBuilder
                            {
                                Name     = e.Name,
                                Value    = e.Value,
                                IsInline = e.Inline
                            };

                            return(builderSelect);
                        }));

                        await registeredChannel.SendMessageAsync(embed : builder.Build());

                        await newUserMessage.DeleteAsync();

                        // await newUserMessage.ModifyAsync("Approved.");
                    }
                    else if (newUserMessage.Reactions.FirstOrDefault(e => e.Emoji.Name == "\u274E")?.Count > 1)
                    {
                        string[] allRegLines = await File.ReadAllLinesAsync(Path.Combine(Globals.AppPath, "Registrations",
                                                                                         $"{newUserMessage.Id}"));

                        ulong userId = Convert.ToUInt64(allRegLines[0]);

                        DiscordGuild guild = await Client.GetGuildAsync(570743985530863649);

                        DiscordMember registeredUser = await guild.GetMemberAsync(userId);

                        DiscordEmbed registrationEmbed = newUserMessage.Embeds.First();

                        DiscordEmbedBuilder builder = new DiscordEmbedBuilder
                        {
                            Description =
                                $"**User {registeredUser.Mention} ({registeredUser.Username}#{registeredUser.Discriminator}) has been denied.**"
                        };

                        builder.WithFields(registrationEmbed.Fields.Select(e =>
                        {
                            DiscordFieldBuilder builderSelect = new DiscordFieldBuilder
                            {
                                Name     = e.Name,
                                Value    = e.Value,
                                IsInline = e.Inline
                            };

                            return(builderSelect);
                        }));

                        if (registrationEmbed.Image?.Url != null)
                        {
                            builder.ImageUrl = registrationEmbed.Image.Url.AbsolutePath;
                        }

                        await registeredChannel.SendMessageAsync(embed : builder.Build());

                        await newUserMessage.DeleteAsync();

                        File.Delete(Path.Combine(Globals.AppPath, "Registrations", $"{newUserMessage.Id}"));
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
Exemplo n.º 15
0
        public async Task Join(CommandContext ctx, int lobbyNum = 0)
        {
            if (!(ctx.User is DiscordMember))
            {
                return;
            }

            DiscordMember player = (DiscordMember)ctx.User;

            LobbyEligibilityResponse lobbyEligibility = Matchmaker.LobbyEligibility(player.Id);

            if (!lobbyEligibility.Success)
            {
                await ctx.RespondAsync(lobbyEligibility.Message);

                return;
            }

            SdlPlayer sdlPlayer;

            try
            {
                sdlPlayer = await MySqlClient.RetrieveSdlPlayer(player.Id);
            }
            catch (SdlMySqlException exception)
            {
                Logger.Error(exception);

                switch (exception.Type)
                {
                case SdlMySqlException.ExceptionType.ZeroUpdates:
                    await(await ctx.Guild.GetMemberAsync((await Program.Client.GetCurrentApplicationAsync()).Owner
                                                         .Id)).SendMessageAsync(exception.Message);

                    await ctx.RespondAsync("Cannot find your record in the database. " +
                                           "Most likely either you have not registered or are not registered correctly.");

                    break;

                case SdlMySqlException.ExceptionType.DuplicateEntry:
                    await(await ctx.Guild.GetMemberAsync((await Program.Client.GetCurrentApplicationAsync()).Owner
                                                         .Id)).SendMessageAsync(exception.Message);

                    await ctx.RespondAsync("There was an error retrieving your player record.");

                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                return;
            }

            int?num = null;

            if (lobbyNum != 0)
            {
                num = lobbyNum;
            }

            await this.JoinLobby(ctx, sdlPlayer, lobbyNumber : num);
        }
        public static async Task MoveToMatch(DiscordChannel context, Set set)
        {
            await context.SendMessageAsync("Both teams are drafted! Please wait while roles are being distributed...");

            DiscordRole alphaRole = context.Guild.Roles.First(e => e.Name == $"Alpha ({set.SetNumber})");
            DiscordRole bravoRole = context.Guild.Roles.First(e => e.Name == $"Bravo ({set.SetNumber})");

            foreach (SdlPlayer alphaTeamPlayer in set.AlphaTeam.Players)
            {
                await(await context.Guild.GetMemberAsync(alphaTeamPlayer.DiscordId)).GrantRoleAsync(alphaRole);
            }

            foreach (SdlPlayer bravoTeamPlayer in set.BravoTeam.Players)
            {
                await(await context.Guild.GetMemberAsync(bravoTeamPlayer.DiscordId)).GrantRoleAsync(bravoRole);
            }

            await context.Guild.UpdateRoleAsync(alphaRole, mentionable : true);

            await context.Guild.UpdateRoleAsync(bravoRole, mentionable : true);

            await context.SendMessageAsync($"{alphaRole.Mention} {bravoRole.Mention} To begin, please join your respective voice channels.\n" +
                                           $"After everyone is situated, please create and join a Private Battle and have the host select the map and mode chosen after this message. " +
                                           $"Once the match is over, the captain of the **losing team** will use %score to report the score like so:\n" +
                                           $"`%score`");

            set.MatchNum = 1;

            SelectHostResponse selectHostResponse = Matchmaker.SelectHost(set);

            if (!selectHostResponse.Success || selectHostResponse.DiscordId == null)
            {
                if (selectHostResponse.Message != null)
                {
                    await context.SendMessageAsync(selectHostResponse.Message);
                }

                if (selectHostResponse.Exception != null)
                {
                    Logger.Error(selectHostResponse.Exception);
                }

                return;
            }

            DiscordMember hostUser = await context.Guild.GetMemberAsync(selectHostResponse.DiscordId.Value);

            set.Host = set.AllPlayers.First(e => e.DiscordId == hostUser.Id);

            Stage[] mapList = await MySqlClient.GetMapList();

            set.PickStages(mapList);
            Stage selectedStage = set.GetCurrentStage();

            DiscordEmbedBuilder embed = new DiscordEmbedBuilder
            {
                Title       = $"Stages for Set #{set.SetNumber}",
                Description =
                    string.Join("\n", set.Stages.Select(x => $"<:{x.GetModeEmote().Name}:{x.GetModeEmote().Id}> {x.MapName}"))
            };

            await context.Guild.GetChannel(601123765237186560).SendMessageAsync(embed: embed.Build());

            await context.SendMessageAsync(embed : selectedStage
                                           .GetEmbedBuilder($"Match 1 of 7: {selectedStage.MapName}")
                                           .AddField(e =>
            {
                e.Name = "Alpha Team's Score";
                e.Value = set.AlphaTeam.Score;
                e.IsInline = true;
            })
                                           .AddField(e =>
            {
                e.Name = "Bravo Team's Score";
                e.Value = set.BravoTeam.Score;
                e.IsInline = true;
            })
                                           .Build());

            await context.SendMessageAsync($"{hostUser.Mention} has been selected as host! The password will be **{hostUser.Discriminator}**. " +
                                           $"Note that if this person is not capable of hosting (due to internet connection etc.) " +
                                           $"it is fine for another person to do so, however keep in mind that situation permitting this person is **first choice** as host.");

            await context.SendMessageAsync("🦑Now then. let the games commence!🐙");

            OrderedFeedMessages[set.SetNumber - 1] =
                (await context.Guild.GetChannel(666563839646760960)
                 .SendMessageAsync(embed: set.GetFeedEmbedBuilder(context).Build()))
                .Id;

            DiscordRole setRole = context.Guild.Roles.First(e => e.Name == $"In Set ({set.SetNumber})");

            foreach (SdlPlayer allPlayer in set.AllPlayers)
            {
                await(await context.Guild.GetMemberAsync(allPlayer.DiscordId)).RevokeRoleAsync(setRole);
            }
        }
        private async Task EndMatchAsync(Set playerSet, CommandContext ctx)
        {
            decimal points = await ReportScores(playerSet);

            //TimePeriod happyPeriod = new TimePeriod(TimeSpan.Parse("20:00"), TimeSpan.Parse("21:00"));
            //TimePeriod halfPeriod = new TimePeriod(TimeSpan.Parse("1:00"), TimeSpan.Parse("2:00"));

            DiscordEmbed setEmbed = playerSet.GetScoreEmbedBuilder(points,

                                                                   /*happyPeriod.IsWithinPeriod(playerSet.StartTime.GetValueOrDefault()) ||
                                                                    * halfPeriod.IsWithinPeriod(playerSet.StartTime.GetValueOrDefault())
                                                                    *  ? points / 2
                                                                    *  :*/points).Build();

            await ctx.RespondAsync($"Congratulations Team {playerSet.Winning} on their victory! " +
                                   $"Everyone's power levels have been updated to reflect this match. " +
                                   $"Beginning removal of access to this channel in 30 seconds. " +
                                   $"Rate limiting may cause the full process to take up to two minutes.",
                                   embed : setEmbed);

            DiscordMessage feedMessage = (DiscordMessage)await ctx.Guild.GetChannel(666563839646760960).GetMessageAsync(OrderedFeedMessages[playerSet.SetNumber - 1]);

            DiscordEmbedBuilder feedEmbedBuilder = playerSet.GetFeedEmbedBuilder(ctx.Channel).WithColor(Color.Green);

            feedEmbedBuilder.Description = $"**{playerSet.Winning}** has won with a score of {playerSet.AlphaTeam.Score}-{playerSet.BravoTeam.Score}!";
            await feedMessage.ModifyAsync(embed : feedEmbedBuilder.Build());

            await Task.Delay(30000);

            List <DiscordRole> roleRemovalList = CommandHelper.DraftRoleIds.Select(e => ctx.Guild.GetRole(e)).ToList();

            foreach (SdlPlayer playerSetAllPlayer in playerSet.AllPlayers)
            {
                DiscordMember guildUser = await ctx.Guild.GetMemberAsync(playerSetAllPlayer.DiscordId);

                foreach (DiscordRole discordRole in roleRemovalList.Where(e =>
                                                                          ctx.Guild.GetMemberAsync(guildUser.Id).Result.Roles
                                                                          .Any(f => e.Id == f.Id)))
                {
                    await guildUser.RevokeRoleAsync(discordRole);
                }
            }

            playerSet.Close();

            DiscordRole classOneRole   = ctx.Guild.GetRole(600770643075661824);
            DiscordRole classTwoRole   = ctx.Guild.GetRole(600770814521901076);
            DiscordRole classThreeRole = ctx.Guild.GetRole(600770862307606542);
            DiscordRole classFourRole  = ctx.Guild.GetRole(600770905282576406);

            DiscordRole[] allClassRoles = { classOneRole, classTwoRole, classThreeRole, classFourRole };

            string optOutDirectory = Directory.CreateDirectory(Path.Combine(Globals.AppPath, "Opt Out")).FullName;

            foreach (SdlPlayer sdlPlayer in await MySqlClient.RetrieveAllSdlPlayers())
            {
                try
                {
                    DiscordMember sdlGuildUser = await ctx.Guild.GetMemberAsync(sdlPlayer.DiscordId);

                    if (File.Exists(Path.Combine(optOutDirectory, $"{sdlGuildUser.Id}.dat")))
                    {
                        continue;
                    }

                    switch (Matchmaker.GetClass(sdlPlayer.PowerLevel))
                    {
                    case SdlClass.Zero:
                        break;

                    case SdlClass.One:
                        if (sdlGuildUser.Roles.All(e => e.Id != classOneRole.Id))
                        {
                            await sdlGuildUser.RemoveRolesAsync(allClassRoles.Where(e =>
                                                                                    sdlGuildUser.Roles.Any(f => f.Id == e.Id)));

                            await sdlGuildUser.GrantRoleAsync(classOneRole);
                        }
                        break;

                    case SdlClass.Two:
                        if (sdlGuildUser.Roles.All(e => e.Id != classTwoRole.Id))
                        {
                            await sdlGuildUser.RemoveRolesAsync(allClassRoles.Where(e =>
                                                                                    sdlGuildUser.Roles.Any(f => f.Id == e.Id)));

                            await sdlGuildUser.GrantRoleAsync(classTwoRole);
                        }
                        break;

                    case SdlClass.Three:
                        if (sdlGuildUser.Roles.All(e => e.Id != classThreeRole.Id))
                        {
                            await sdlGuildUser.RemoveRolesAsync(allClassRoles.Where(e =>
                                                                                    sdlGuildUser.Roles.Any(f => f.Id == e.Id)));

                            await sdlGuildUser.GrantRoleAsync(classThreeRole);
                        }
                        break;

                    case SdlClass.Four:
                        if (sdlGuildUser.Roles.All(e => e.Id != classFourRole.Id))
                        {
                            await sdlGuildUser.RemoveRolesAsync(allClassRoles.Where(e =>
                                                                                    sdlGuildUser.Roles.Any(f => f.Id == e.Id)));

                            await sdlGuildUser.GrantRoleAsync(classFourRole);
                        }
                        break;

                    default:
                        break;
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            }

            // TODO Removed message clearing for the time being.
            if (ctx.Channel.Id == 0 /*CommandHelper.ChannelFromSet(playerSet.SetNumber).Id*/)
            {
                /*IEnumerable<IMessage> messages = await ctx.Channel.GetMessagesAsync(1000 + 1).FlattenAsync();
                 *
                 * await ((ITextChannel) ctx.Channel).DeleteMessagesAsync(messages);
                 *
                 * DiscordMessage reply =
                 *  await ctx.RespondAsync(
                 *      "Cleared the channel of 1000 messages. This message will be deleted in 10 seconds as well.");
                 *
                 * await Task.Delay(10000);
                 *
                 * await reply.DeleteAsync();*/
            }
        }
        public async Task Notif(CommandContext ctx)
        {
            if (!(ctx.User is DiscordMember user))
            {
                return;
            }

            if (user.Roles.All(e => e.Name != "Player"))
            {
                return;
            }

            SdlPlayer player = await MySqlClient.RetrieveSdlPlayer(user.Id);

            DiscordRole classOneRole   = ctx.Guild.GetRole(600770643075661824);
            DiscordRole classTwoRole   = ctx.Guild.GetRole(600770814521901076);
            DiscordRole classThreeRole = ctx.Guild.GetRole(600770862307606542);
            DiscordRole classFourRole  = ctx.Guild.GetRole(600770905282576406);

            DiscordRole selectedRole = null;

            switch (Matchmaker.GetClass(player.PowerLevel))
            {
            case SdlClass.Zero:
                break;

            case SdlClass.One:
                selectedRole = classOneRole;
                break;

            case SdlClass.Two:
                selectedRole = classTwoRole;
                break;

            case SdlClass.Three:
                selectedRole = classThreeRole;
                break;

            case SdlClass.Four:
                selectedRole = classFourRole;
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            string optOutDirectory = Directory.CreateDirectory(Path.Combine(Globals.AppPath, "Opt Out")).FullName;

            if (user.Roles.Any(e => e.Id == selectedRole?.Id))
            {
                await File.WriteAllTextAsync(Path.Combine(optOutDirectory, $"{ctx.User.Id}.dat"), "bruh");

                await user.RevokeRoleAsync(selectedRole);

                await ctx.RespondAsync("Disabled lobby notifications.");
            }
            else
            {
                if (File.Exists(Path.Combine(optOutDirectory, $"{ctx.User.Id}.dat")))
                {
                    File.Delete(Path.Combine(optOutDirectory, $"{ctx.User.Id}.dat"));
                }

                await user.RevokeRoleAsync(selectedRole);

                await ctx.RespondAsync("Enabled lobby notifications.");
            }
        }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="study"></param>
 /// <returns></returns>
 private List<string> getEmails(Study study)
 {
     List<String> emails = new List<string>();
     Matchmaker matchmaker = new Matchmaker(new Study(study.StudyID));
     foreach (KeyValuePair<Participant, int> result in matchmaker.Results) {
         emails.Add(result.Key.Email);
     }
     tbEmailList.Visible = true;
     lblEmailStatus.Visible = true;
     return emails;
 }
 private void Start()
 {
     instance = this;
 }
    public void HostGame()
    {
        string matchID = Matchmaker.GetRandomMatchID();

        CmdHostGame(matchID);
    }
Exemplo n.º 22
0
 void OnMatchmakingError(string errorInfo)
 {
     Debug.Log($"Matchmaking failed! Error is: {errorInfo}.");
     m_UseMatchmaking = false;
     m_Matchmaker     = null;
 }
Exemplo n.º 23
0
 public Matchmaker RegisterMatchmaker([FromBody] Matchmaker value)
 {
     return(MatchmakerBL.RegisterMatchmaker(value));
 }
Exemplo n.º 24
0
 /// <summary>Get a references to components we will use often</summary>
 void Awake()
 {
     matchUp        = GetComponent <Matchmaker>();
     networkManager = GetComponent <NetworkManager>();
 }