Beispiel #1
0
    void Awake()
    {
        #region Singleton boilerplate

        if (Singleton != null)
        {
            if (Singleton != this)
            {
                Debug.LogWarning($"There's more than one {Singleton.GetType()} in the scene!");
                Destroy(gameObject);
            }

            return;
        }

        Singleton = this;

        #endregion Singleton boilerplate

        spawnProbabilityWeightSum = 0;
        foreach (EnemySpawnData spawnData in enemyPrefabs)
        {
            if (spawnData.probabilityWeight <= 0)
            {
                Debug.LogError($"A probability weight cannot be less than 1! Was {spawnData.probabilityWeight} for \"{spawnData.prefab}\"");
            }
            spawnProbabilityWeightSum += spawnData.probabilityWeight;
        }
    }
 public static LeaderBoard GetLeaderBoard(RankEnum type = RankEnum.Level, EndlessMode mode = EndlessMode.Default)
 {
     if (type == RankEnum.Level)
     {
         mode = EndlessMode.Default;
     }
     return(leaderBoards[new Tuple <RankEnum, EndlessMode>(type, mode)]);
 }
Beispiel #3
0
 public EndlessBattleEnvironment(string Name, ITextChannel lobbyChannel, bool isPersistent, ITextChannel BattleChannel, EndlessMode mode = EndlessMode.Default) : base(Name, lobbyChannel, isPersistent, BattleChannel)
 {
     this.mode = mode;
     if (mode == EndlessMode.Legacy)
     {
         Factory = new PlayerFighterFactory()
         {
             DjinnOption = DjinnOption.NoDjinn, ReductionFactor = 1.5
         };
     }
     _ = Reset();
 }
    void LevelComplete()
    {
        if (gameLevel != 3)
        {
            bIsPlayerAlive = false;
            nextLevelMenu.SetActive(true);
        }
        else if (gameLevel == 3)
        {
            endlessMode.SetActive(true);

            EndlessMode mode = endlessMode.GetComponent <EndlessMode>();
            mode.IncreaseDifficulty();
            IncreaseDifficulty(cameraIncreaseSpeed);

            cameraPauseDuration = 0.0f;
            Debug.Log("BEGIN ENDLESS MODE");
        }
    }
Beispiel #5
0
        public static List <UserAccount> GetTop(RankEnum type = RankEnum.Level, EndlessMode mode = EndlessMode.Default)
        {
            List <UserAccount> sortedList = null;

            switch (type)
            {
            case RankEnum.Level:
            case RankEnum.Solo:
                try
                {
                    sortedList = UserAccountProvider.GetLeaderBoard(type, mode)
                                 .Take(10)
                                 .ToList()
                                 .Select(id => UserAccountProvider.GetById(id.Key))
                                 .ToList();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }

                break;

            case RankEnum.Duo:
            case RankEnum.Trio:
            case RankEnum.Quad:
                sortedList = UserAccountProvider.GetLeaderBoard(type, mode)
                             .Take(20)
                             .Select(id => UserAccountProvider.GetById(id.Key))
                             .GroupBy(p =>
                                      (p.ServerStats.GetStreak(mode) + p.ServerStatsTotal.GetStreak(mode)).GetEntry(type).Item2)
                             .Select(group => group.First())
                             .OrderByDescending(d =>
                                                (d.ServerStats.GetStreak(mode) + d.ServerStatsTotal.GetStreak(mode)).GetEntry(type).Item1)
                             .ToList();
                break;
            }

            return(sortedList);
        }
    // Start is called before the first frame update
    private void Start()
    {
        levelCompleted = false;
        origin         = new Vector3(x: origin2D.x, y: origin2D.y);

        // Check if values make sense
        if (minSkipPercentage > maxSkipPercentage)
        {
            Debug.LogError("Min skip percentage is greater than max: " + minSkipPercentage + " " + maxSkipPercentage);
        }
        if (minBlockShiftInterval > maxBlockShiftInterval)
        {
            Debug.LogError("Min block shift interval greater than max: " + minBlockShiftInterval + " " + maxBlockShiftInterval);
        }



        // Load player data. Set current level
        currentLevel = GameManager.Instance.GetPlayerData().currentLevel;
        SetGameData(currentLevel);

        // Play level text animation
        SetLevelAndAnimate("LEVEL " + currentLevel);

        // Generate a few rows to start the level off
        int numStartingRows = 10;

        for (int i = 0; i < numStartingRows; i++)
        {
            float             skipPercentage = Random.Range(min: minSkipPercentage, max: maxSkipPercentage);
            Vector3           rowOrigin      = new Vector3(x: origin.x, y: origin.y - numStartingRows + i);
            List <GameObject> row            = EndlessMode.GenerateRowOfBlocks(rowLength: levelWidth, blocks: blockPrefabs, skipPercentage: skipPercentage, origin: rowOrigin, parent: tilemap);
            blocks.AddRange(row);
        }
        rowSpawnCount = numStartingRows;
    }
    // Update is called once per frame
    private void Update()
    {
        if (levelCompleted || gameIsPaused)
        {
            return;
        }

        // Remove all null/destroyed blocks
        // https://stackoverflow.com/questions/3069748/how-to-remove-all-the-null-elements-inside-a-generic-list-in-one-go
        blocks.RemoveAll(item => item == null);

        // Check for win condition
        if (rowSpawnCount >= rowsToSpawn)
        {
            if (blocks.Count == 0)
            {
                // Mission Complete!
                Debug.Log("MISSION COMPLETE!");
                levelCompleted = true;
                StartCoroutine(FadeToMenu());
            }
        }

        // on timer, move old blocks down one level
        // and generate new round of blocks above
        timeSinceLastBlockShift += Time.deltaTime;

        // Check blockShift timer
        if (timeSinceLastBlockShift > blockShiftInterval)
        {
            // If we've reached this point, it is time to shift all rows of blocks

            // Reset blockShift timer
            timeSinceLastBlockShift = 0;

            // Generate new row of blocks if the limit has not been reached
            if (rowSpawnCount < rowsToSpawn)
            {
                float             skipPercentage = Random.Range(min: minSkipPercentage, max: maxSkipPercentage);
                List <GameObject> row            = EndlessMode.GenerateRowOfBlocks(rowLength: levelWidth, blocks: blockPrefabs, skipPercentage: skipPercentage, origin: origin, parent: tilemap);
                blocks.AddRange(row);
                rowSpawnCount++;
            }

            // Shift blocks down
            EndlessMode.ShiftBlocksDown(blocks, this);
        }

        // Check for GameOver condition
        // Note because the blocks spawn in from left to right, with the lowest row spawning first,
        // the first block in the blocks array will always be the lowest leftmost block.
        if (blocks.Count > 0)
        {
            if (blocks[0].transform.position.y <= bottomY)
            {
                // Game Over
                Debug.Log("Block hit the bottom wall! GameOver!!");
                EndlessModeManager.Instance.DidTriggerGameOver();
            }
        }
    }
Beispiel #8
0
        internal static async Task UserFinishedEndless(UserAccount avatar, ITextChannel lobbyChannel, int winsInARow, EndlessMode mode)
        {
            string csvline = $"{DateTime.Now.TimeOfDay},Endless {mode},{winsInARow},{avatar.Name}{Environment.NewLine}";

            File.AppendAllText(BattleFile, csvline);
            await Task.CompletedTask;
        }
Beispiel #9
0
        internal static async Task UserWonEndless(UserAccount avatar, ITextChannel lobbyChannel, int winsInARow, EndlessMode mode, int nOfPlayers, string TeamMatesNames)
        {
            if (mode == EndlessMode.Default)
            {
                avatar.ServerStats.EndlessStreak.AddStreak(winsInARow, nOfPlayers, TeamMatesNames);
            }
            else
            {
                avatar.ServerStats.LegacyStreak.AddStreak(winsInARow, nOfPlayers, TeamMatesNames);
            }

            await Task.CompletedTask;
        }
Beispiel #10
0
        public async Task Showdown(RankEnum type = RankEnum.Solo, EndlessMode mode = EndlessMode.Default)
        {
            var topAccounts = UserAccounts.GetTop(type, mode);

            if (type == RankEnum.Solo)
                topAccounts = topAccounts.OrderByDescending(d =>
                    (d.ServerStats.GetStreak(mode) + d.ServerStatsTotal.GetStreak(mode)).Solo).ToList();
            else
                topAccounts = topAccounts.Where(p =>
                        (p.ServerStats.GetStreak(mode) + p.ServerStatsTotal.GetStreak(mode)).GetEntry(type).Item1 > 0)
                    .GroupBy(p =>
                        (p.ServerStats.GetStreak(mode) + p.ServerStatsTotal.GetStreak(mode)).GetEntry(type).Item2)
                    .Select(group => group.First())
                    .OrderByDescending(d =>
                        (d.ServerStats.GetStreak(mode) + d.ServerStatsTotal.GetStreak(mode)).GetEntry(type).Item1)
                    .ToList();
            var embed = new EmbedBuilder();
            embed.WithColor(Colors.Get("Iodem"));
            string[] emotes = { "🥇", "🥈", "🥉", "", "" };
            var builder = new StringBuilder();
            for (var i = 0; i < Math.Min(topAccounts.Count, 5); i++)
            {
                var curAccount = topAccounts.ElementAt(i);
                var streak = mode == EndlessMode.Default
                    ? curAccount.ServerStats.EndlessStreak + curAccount.ServerStatsTotal.EndlessStreak
                    : curAccount.ServerStats.LegacyStreak + curAccount.ServerStatsTotal.LegacyStreak;
                switch (type)
                {
                    case RankEnum.Solo:
                        builder.Append($"`{i + 1}` {emotes[i]} {curAccount.Name,-15} - `{streak.Solo}`\n");
                        break;

                    case RankEnum.Duo:
                        builder.Append($"`{i + 1}` {emotes[i]} {streak.DuoNames} - `{streak.Duo}`\n");
                        break;

                    case RankEnum.Trio:
                        builder.Append($"`{i + 1}` {emotes[i]} {streak.TrioNames} - `{streak.Trio}`\n");
                        break;

                    case RankEnum.Quad:
                        builder.Append($"`{i + 1}` {emotes[i]} {streak.QuadNames} - `{streak.Quad}`\n");
                        break;
                }
            }

            //Console.WriteLine(rank);
            var account = EntityConverter.ConvertUser(Context.User);
            var rank = UserAccounts.GetRank(account, type, mode);
            if (rank >= 5)
            {
                builder.Append("... \n");
                var streak = mode == EndlessMode.Default
                    ? account.ServerStats.EndlessStreak + account.ServerStatsTotal.EndlessStreak
                    : account.ServerStats.LegacyStreak + account.ServerStatsTotal.LegacyStreak;
                switch (type)
                {
                    case RankEnum.Solo:
                        builder.Append($"`{rank + 1}` {account.Name,-15} - `{streak.Solo}`");
                        break;

                    case RankEnum.Duo:
                        builder.Append($"{streak.DuoNames} - `{streak.Duo}`");
                        break;

                    case RankEnum.Trio:
                        builder.Append($"{streak.TrioNames} - `{streak.Trio}`");
                        break;

                    case RankEnum.Quad:
                        builder.Append($"{streak.QuadNames} - `{streak.Quad}`");
                        break;
                }
            }

            if (type == RankEnum.Solo && mode == EndlessMode.Legacy)
                embed.WithFooter("Honorary Mention: Smeecko - 81, by breaking the Time-Space Continuum");
            embed.WithDescription(builder.ToString());

            await Context.Channel.SendMessageAsync("", false, embed.Build());
        }
 public static int GetRank(UserAccount user, RankEnum type = RankEnum.Level, EndlessMode mode = EndlessMode.Default)
 {
     return(UserAccountProvider.GetLeaderBoard(type, mode).IndexOf(user.ID));
 }
        /// <summary>
        /// Starts the selected level
        /// </summary>
        /// <param name="sender">not used</param>
        /// <param name="e">not used</param>
        private void startButton_Click(object sender, RoutedEventArgs e)
        {
            int index = (int)cursor.Margin.Top / 20;

            if (campaign && index == 2)
            {
                EndlessMode endlessMode = new EndlessMode();
                endlessMode.Owner = this;
                Hide();
                try
                {
                    endlessMode.ShowDialog();
                }
                catch (Exception)
                {
                    endlessMode.Close();
                    MessageBox.Show("Game data has been modified during play.\nAn error has occurred due to this.\nThe level was aborted.");
                }
                Show();
                return;
            }

            Boolean goodMap = false;
            BasicLevel level = new BasicLevel();

            // Load the map
            if (campaign)
                goodMap = level.LoadCampaign(mapNames[index]);
            else
                goodMap = level.Load(mapNames[index]);

            // If successful, play the map
            if (goodMap)
            {
                Game game = new Game(level);
                game.Owner = this;
                Hide();
                try
                {
                    game.ShowDialog();
                }
                catch (Exception)
                {
                    game.Close();
                    MessageBox.Show("Game data has been modified during play.\nAn error has occurred due to this.\nThe level was aborted.");
                }
                Show();
                return;
            }

            // Remove the map due to not being valid
            grid1.Children.RemoveAt(index + 1);
            for (int i = index + 1; i < grid1.Children.Count; ++i)
            {
                Label l = grid1.Children[i] as Label;
                l.Margin = new Thickness(l.Margin.Left, l.Margin.Top - 20, 0, 0);
            }
            if (grid1.Children.Count == 1)
            {
                MessageBox.Show("There are no more maps available");
                Close();
            }
            else if (index == grid1.Children.Count - 1)
            {
                cursor.Margin = new Thickness(8, 20 * index - 16, 0, 0);
            }
        }
Beispiel #13
0
        public async Task Showdown(RankEnum type = RankEnum.Solo, EndlessMode mode = EndlessMode.Default)
        {
            var topAccounts = UserAccounts.GetTop(type, mode).Take(10);
            var embed       = new EmbedBuilder();

            embed.WithColor(Colors.Get("Iodem"));
            string[] Emotes  = new string[] { "🥇", "🥈", "🥉", "", "" };
            var      builder = new StringBuilder();

            for (int i = 0; i < Math.Min(topAccounts.Count(), 5); i++)
            {
                var curAccount = topAccounts.ElementAt(i);
                var streak     = mode == EndlessMode.Default ? curAccount.ServerStats.EndlessStreak + curAccount.ServerStatsTotal.EndlessStreak : curAccount.ServerStats.LegacyStreak + curAccount.ServerStats.EndlessStreak;
                switch (type)
                {
                case RankEnum.Solo:
                    builder.Append($"`{i + 1}` {Emotes[i]} {curAccount.Name,-15} - `{streak.Solo}`\n");
                    break;

                case RankEnum.Duo:
                    builder.Append($"`{i + 1}` {Emotes[i]} {streak.DuoNames} - `{streak.Duo}`\n");
                    break;

                case RankEnum.Trio:
                    builder.Append($"`{i + 1}` {Emotes[i]} {streak.TrioNames} - `{streak.Trio}`\n");
                    break;

                case RankEnum.Quad:
                    builder.Append($"`{i + 1}` {Emotes[i]} {streak.Quad} - `{streak.QuadNames}\n");
                    break;
                }
            }

            var rank = UserAccounts.GetRank(Context.User, type);
            //Console.WriteLine(rank);
            var account = UserAccounts.GetAccount(Context.User);

            if (rank >= 5)
            {
                builder.Append("... \n");
                var streak = mode == EndlessMode.Default ? account.ServerStats.EndlessStreak + account.ServerStatsTotal.EndlessStreak : account.ServerStats.LegacyStreak + account.ServerStats.EndlessStreak;
                switch (type)
                {
                case RankEnum.Solo:
                    builder.Append($"`{rank + 1}` {account.Name,-15} - `{streak.Solo}`");
                    break;

                case RankEnum.Duo:
                    builder.Append($"`{rank + 1}` {streak.DuoNames} - `{streak.Duo}`");
                    break;

                case RankEnum.Trio:
                    builder.Append($"`{rank + 1}` {streak.TrioNames} - `{streak.Trio}`");
                    break;

                case RankEnum.Quad:
                    builder.Append($"`{rank + 1}` {streak.QuadNames} - `{streak.Quad}`");
                    break;
                }
            }
            if (type == RankEnum.Solo && mode == EndlessMode.Legacy)
            {
                embed.WithFooter("Honorary Mention: Smeecko - 81, by breaking the Time-Space Continuum");
            }
            embed.WithDescription(builder.ToString());

            await Context.Channel.SendMessageAsync("", false, embed.Build());
        }
Beispiel #14
0
 public EndlessStreak GetStreak(EndlessMode mode) => mode == EndlessMode.Default ? EndlessStreak : LegacyStreak;
 void Start()
 {
     gameManager = EndlessMode.Singleton;
 }
Beispiel #16
0
 internal static async Task UserWonEndless(UserAccount avatar, int winsInARow, EndlessMode mode, int nOfPlayers,
                                           string teamMatesNames)
 {
     if (mode == EndlessMode.Default)
     {
         avatar.ServerStats.EndlessStreak.AddStreak(winsInARow, nOfPlayers, teamMatesNames);
     }
     else
     {
         avatar.ServerStats.LegacyStreak.AddStreak(winsInARow, nOfPlayers, teamMatesNames);
     }
     UserAccountProvider.StoreUser(avatar);
     await Task.CompletedTask;
 }