Ejemplo n.º 1
0
        private async Task AddPlayer(SocketReaction reaction)
        {
            if (Battle.isActive)
            {
                return;
            }

            if (Messages.Values.Where(v => v is PlayerFighter).Where(s => ((PlayerFighter)s).avatar.ID == reaction.UserId).Any())
            {
                return;
            }

            SocketGuildUser player       = (SocketGuildUser)reaction.User.Value;
            var             playerAvatar = UserAccounts.GetAccount(player);

            var p = new PlayerFighter(player);

            Battle.AddPlayer(p, ColossoBattle.Team.A);

            if (playerAvatar.Inv.GetGear(AdeptClassSeriesManager.GetClassSeries(playerAvatar).Archtype).Any(i => i.Name == "Lure Cap"))
            {
                LureCaps++;
                SetRandomEnemies(ColossoBattle.Team.B);
            }

            if (Name == "Bronze")
            {
                if (playerAvatar.LevelNumber < 10 && Messages.Count == 0)
                {
                    Diff = BattleDifficulty.Tutorial;
                    SetRandomEnemies(ColossoBattle.Team.B);
                }
                else
                {
                    if (Diff != BattleDifficulty.Easy)
                    {
                        Diff = BattleDifficulty.Easy;
                        SetRandomEnemies(ColossoBattle.Team.B);
                    }
                }
            }

            var playerMsg = await BattleChannel.SendMessageAsync($"{player.DisplayName()} wants to battle!");

            Messages.Add(playerMsg, p);
            resetIfNotActive.Start();

            if (Messages.Count == PlayersToStart)
            {
                await StartBattle();
            }
        }
 protected override async Task AddPlayer(PlayerFighter player, Team team)
 {
     if (team == Team.B)
     {
         player.Stats            *= new GoldenSunMechanics.Stats(1000, 100, 200, 200, 10);
         player.Stats            *= 0.01;
         player.Name              = $"Goliath {player.Name}";
         player.IsImmuneToOHKO    = true;
         player.IsImmuneToHPtoOne = true;
         player.AddCondition(Condition.DeathCurse);
         player.DeathCurseCounter = 10;
     }
     await base.AddPlayer(player, team);
 }
Ejemplo n.º 3
0
        protected virtual async Task AddPlayer(PlayerFighter player, Team team)
        {
            if (Battle.isActive)
            {
                return;
            }

            Battle.AddPlayer(player, team);

            var playerMsg = await Teams[team].teamChannel.SendMessageAsync($"{player.Name} wants to battle!");

            Teams[team].PlayerMessages.Add(playerMsg, player);
            resetIfNotActive.Start();

            if (Teams[Team.A].PlayerMessages.Count == PlayersToStart && Teams[Team.B].PlayerMessages.Count == PlayersToStartB)
            {
                await StartBattle();
            }
        }
Ejemplo n.º 4
0
        protected virtual async Task AddPlayer(PlayerFighter player)
        {
            if (Battle.isActive)
            {
                return;
            }

            Battle.AddPlayer(player, Team.A);

            var playerMsg = await BattleChannel.SendMessageAsync($"{player.Name} wants to battle!");

            PlayerMessages.Add(playerMsg, player);
            resetIfNotActive.Stop();
            resetIfNotActive.Start();

            if (PlayerMessages.Count == PlayersToStart)
            {
                await StartBattle();
            }
        }
Ejemplo n.º 5
0
        public PlayerFighter CreatePlayerFighter(SocketUser user)
        {
            var p      = new PlayerFighter();
            var avatar = UserAccounts.GetAccount(user);

            p.Name    = (user is SocketGuildUser) ? ((SocketGuildUser)user).DisplayName() : user.Username;
            p.avatar  = avatar;
            p.ImgUrl  = user.GetAvatarUrl();
            p.factory = this;
            if (user is SocketGuildUser)
            {
                p.guildUser = (SocketGuildUser)user;
            }
            p.Moves = AdeptClassSeriesManager.GetMoveset(avatar);

            var Class       = AdeptClassSeriesManager.GetClass(avatar);
            var classSeries = AdeptClassSeriesManager.GetClassSeries(avatar);

            p.Stats   = GetStats(avatar);
            p.ElStats = AdeptClassSeriesManager.GetElStats(avatar);
            if (classSeries.Name == "Curse Mage Series" || classSeries.Name == "Medium Series")
            {
                p.IsImmuneToItemCurse = true;
            }

            switch (InventoryOption)
            {
            case InventoryOption.Default:
                var gear = avatar.Inv.GetGear(classSeries.Archtype);
                gear.ForEach(g =>
                {
                    p.Stats += g.AddStatsOnEquip;
                });
                gear.ForEach(g =>
                {
                    p.ElStats += g.AddElStatsOnEquip;
                });
                gear.ForEach(g =>
                {
                    p.Stats *= g.MultStatsOnEquip;
                    p.Stats *= 0.01;
                });

                gear.OrderBy(i => i.ItemType).ToList().ForEach(g =>
                {
                    p.HPrecovery  += g.HPRegen;
                    p.PPrecovery  += g.PPRegen;
                    p.unleashRate += g.IncreaseUnleashRate;
                    if (g.IsCursed)
                    {
                        p.AddCondition(Condition.ItemCurse);
                    }

                    if (g.CuresCurse)
                    {
                        p.IsImmuneToItemCurse = true;
                    }

                    if (g.Category == ItemCategory.Weapon)
                    {
                        p.Weapon = g;
                        if (p.Weapon.IsUnleashable)
                        {
                            p.Weapon.Unleash.AdditionalEffects.Clear();
                        }
                    }
                    else if (g.IsUnleashable)
                    {
                        if (g.GrantsUnleash)
                        {
                            if ((p.Weapon != null) && p.Weapon.IsUnleashable)
                            {
                                p.Weapon.Unleash.AdditionalEffects.AddRange(g.Unleash.Effects);
                            }
                        }
                        else
                        {
                            p.EquipmentWithEffect.Add(g);
                        }
                    }
                });
                p.HPrecovery = (int)(p.HPrecovery * (1 + (double)avatar.LevelNumber / 33));

                break;

            case InventoryOption.NoInventory:
                break;
            }

            switch (DjinnOption)
            {
            case DjinnOption.Default:
                break;

            case DjinnOption.NoDjinn:
                break;
            }

            p.Stats *= Class.StatMultipliers;
            p.Stats *= 0.01;
            p.Stats *= StatMultiplier;
            p.Stats *= 0.01;

            return(p);
        }