예제 #1
0
        public async Task RandomItemAsync(CommandContext ctx, int nivel = 1, [RemainingText] DiscordUser member = null)
        {
            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco = new BancoSession(session);
                if (member == null)
                {
                    member = ctx.User;
                }
                RPJogador jogador = await banco.GetJogadorAsync(member);

                RPPersonagem personagem = jogador.Personagem;

                var niveisSeparados = RPMetadata.Itens.Where(x => x.Key <= nivel);

                Random r            = new Random();
                var    itens        = niveisSeparados.ElementAt(r.Next(0, niveisSeparados.Count()));
                var    itemSorteado = itens.ElementAt(r.Next(0, itens.Count()));
                itemSorteado.ILevel = nivel;

                personagem.Mochila.TryAddItem(itemSorteado);

                await banco.EditJogadorAsync(jogador);

                await session.CommitTransactionAsync();

                await ctx.RespondAsync($"{member.Mention} recebeu {itemSorteado.TipoBaseModificado.Titulo().Bold()}!");
            }
        }
예제 #2
0
        public async Task ComandoPegarAsync(CommandContext ctx, string stringIndexItem = "0")
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            if (personagemNaoModificar.IsPortalAberto)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você não pode usar este comando com o portal aberto!");

                return;
            }

            // Converte o id informado.
            if (!stringIndexItem.TryParseID(out int indexItem))
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, o #ID precisa ser numérico!");

                return;
            }

            if (personagemNaoModificar.Zona.ItensNoChao == null || personagemNaoModificar.Zona.ItensNoChao.Count == 0)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você não tem itens no chão para pegar!");

                return;
            }

            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                var item = personagem.Zona.ItensNoChao.ElementAtOrDefault(indexItem);
                if (item != null)
                {
                    if (personagem.Mochila.TryAddItem(item))
                    {
                        personagem.Zona.ItensNoChao.RemoveAt(indexItem);

                        await banco.EditJogadorAsync(jogador);

                        await session.CommitTransactionAsync();

                        await ctx.RespondAsync($"{ctx.User.Mention}, você pegou {item.TipoBaseModificado.Titulo().Bold()}!");
                    }
                    else
                    {
                        await ctx.RespondAsync($"{ctx.User.Mention}, você não tem espaço o suficiente para pegar {item.TipoBaseModificado.Titulo().Bold()}!!");
                    }
                }
            }
        }
예제 #3
0
        private async Task CriarJogador(CommandContext ctx, RPPersonagem personagem)
        {
            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = new RPJogador(ctx, personagem);
                await banco.AddJogadorAsync(jogador);

                await session.CommitTransactionAsync();

                await ctx.RespondAsync($"{ctx.User.Mention}, o seu personagem {jogador.Personagem.Classe.Titulo()} foi criado!");
            }
        }
예제 #4
0
        public async Task ComandoDescerAsync(CommandContext ctx)
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            int inimigos = 0;

            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                if (personagem.IsPortalAberto)
                {
                    personagem.Zona.Monstros.Clear();
                    personagem.IsPortalAberto = false;
                }
                else if (personagem.Zona.Monstros.Count != 0)
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, você precisa eliminar todos os montros para descer!");

                    return;
                }

                bool temMonstros = RPMetadata.MonstrosNomes.ContainsKey(personagem.Zona.Nivel + 1);
                if (temMonstros)
                {
                    inimigos = personagem.Zona.TrocarZona(personagem.VelocidadeAtaque.Modificado, personagem.Zona.Nivel + 1);

                    await banco.EditJogadorAsync(jogador);

                    await session.CommitTransactionAsync();

                    await ctx.RespondAsync($"{ctx.User.Mention}, apareceu {inimigos} monstro na sua frente!");
                }
                else
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, não existe mais zonas para avançar!");
                }
            }
        }
예제 #5
0
        public async Task matar(CommandContext ctx, DiscordUser member)
        {
            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(member);

                RPPersonagem personagem = jogador.Personagem;

                personagem.Zona.Monstros = new List <RPMonstro>();

                await banco.EditJogadorAsync(jogador);

                await session.CommitTransactionAsync();

                await ctx.RespondAsync($"Inimigos mortos para {member.Mention}!");
            }
        }
예제 #6
0
        public async Task ComandoExplorarAsync(CommandContext ctx)
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            if (personagemNaoModificar.Zona.Monstros.Count != 0)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você precisa eliminar todos os montros para explorar!");

                return;
            }

            if (personagemNaoModificar.Zona.Nivel == 0)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você somente pode explorar os níveis inferiores da torre!");

                return;
            }

            int inimigos = 0;

            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                inimigos = personagem.Zona.TrocarZona(personagem.VelocidadeAtaque.Modificado, personagem.Zona.Nivel);

                await banco.EditJogadorAsync(jogador);

                await session.CommitTransactionAsync();

                await ctx.RespondAsync($"{ctx.User.Mention}, apareceu [{inimigos.Bold()}] monstro na sua frente!");
            }
        }
예제 #7
0
        public async Task Currency(CommandContext ctx, int quantidade = 1)
        {
            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx.User);

                RPPersonagem personagem = jogador.Personagem;

                for (int i = 0; i < quantidade; i++)
                {
                    personagem.Mochila.TryAddItem(new MoedasEmpilhaveis().PergaminhoSabedoria());
                }

                await banco.EditJogadorAsync(jogador);

                await session.CommitTransactionAsync();

                await ctx.RespondAsync($"Adicionado {quantidade}!");
            }
        }
        public async Task ComandoDesequiparAsync(CommandContext ctx, [RemainingText] string itemString = "")
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                RPBaseItem item = null;
                switch (itemString.RemoverAcentos().ToLower())
                {
                case "0":
                case "#0":
                    item = await RemoverFrascoAsync(personagem, ctx, 0);

                    if (item == null)
                    {
                        return;
                    }
                    break;

                case "1":
                case "#1":
                    item = await RemoverFrascoAsync(personagem, ctx, 1);

                    if (item == null)
                    {
                        return;
                    }
                    break;

                case "2":
                case "#2":
                    item = await RemoverFrascoAsync(personagem, ctx, 2);

                    if (item == null)
                    {
                        return;
                    }
                    break;

                case "3":
                case "#3":
                    item = await RemoverFrascoAsync(personagem, ctx, 3);

                    if (item == null)
                    {
                        return;
                    }
                    break;

                case "4":
                case "#4":
                    item = await RemoverFrascoAsync(personagem, ctx, 4);

                    if (item == null)
                    {
                        return;
                    }
                    break;

                case "primeira mao":
                case "mao principal":
                case "primeira":
                case "principal":
                case "mao1":
                case "m1":
                    // Verifica se tem algo equipado
                    if (personagem.MaoPrincipal == null)
                    {
                        // Avisa
                        await ctx.RespondAsync($"{ctx.User.Mention}, você não tem nada equipado na primeira mão.");

                        return;
                    }
                    // Desequipa
                    item = personagem.MaoPrincipal;
                    personagem.MaoPrincipal = null;
                    break;

                case "segunda mao":
                case "segunda":
                case "mao secundaria":
                case "mao2":
                case "m2":
                    // Verifica se tem algo equipado
                    if (personagem.MaoSecundaria == null)
                    {
                        // Avisa
                        await ctx.RespondAsync($"{ctx.User.Mention}, você não tem nada equipado na segunda mão.");

                        return;
                    }
                    // Desequipa
                    item = personagem.MaoSecundaria;
                    personagem.MaoSecundaria = null;
                    break;

                default:
                    await ctx.RespondAsync($"{ctx.User.Mention}, não foi encontrado o {"SLOT".Titulo().Bold()} que você pediu! Digite `!equipamentos` para ver os {"SLOT".Titulo().Bold()} disponíveis.");

                    return;
                }

                // Tenta guardar na mochila
                if (personagem.Mochila.TryAddItem(item))
                {
                    // Remove os atributos
                    switch (item)
                    {
                    case RPBaseItemArma arma:
                        personagem.DanoFisicoExtra.Subtrair(arma.DanoFisicoModificado);
                        personagem.CalcDano();
                        break;
                    }
                }
                else
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, você não tem espaço o suficiente na mochila para desequipar {item.TipoBaseModificado.Titulo().Bold()}!");

                    return;
                }

                await banco.EditJogadorAsync(jogador);

                await session.CommitTransactionAsync();

                await ctx.RespondAsync($"{ctx.User.Mention}, você desequipou {item.TipoBaseModificado.Titulo().Bold()}.");
            }
        }
예제 #9
0
        public async Task ComandoSubirAsync(CommandContext ctx)
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            int inimigos = 0;

            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                if (personagem.IsPortalAberto)
                {
                    personagem.Zona.Monstros.Clear();
                    personagem.IsPortalAberto = false;
                }
                else if (personagem.Zona.Monstros.Count != 0)
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, você precisa eliminar todos os montros para subir!");

                    return;
                }

                bool temMonstros = RPMetadata.MonstrosNomes.ContainsKey(personagem.Zona.Nivel - 1);
                if (temMonstros)
                {
                    inimigos = personagem.Zona.TrocarZona(personagem.VelocidadeAtaque.Modificado, personagem.Zona.Nivel - 1);

                    await banco.EditJogadorAsync(jogador);

                    await session.CommitTransactionAsync();

                    await ctx.RespondAsync($"{ctx.User.Mention}, apareceu {inimigos} monstro na sua frente!");
                }
                else if (personagem.Zona.Nivel - 1 == 0)
                {
                    foreach (var item in personagem.Frascos)
                    {
                        item.AddCarga(double.MaxValue);
                    }
                    personagem.Vida.Adicionar(double.MaxValue);
                    personagem.Mana.Adicionar(double.MaxValue);
                    personagem.Efeitos          = new List <RPEfeito>();
                    personagem.Zona.Nivel       = 0;
                    personagem.Zona.ItensNoChao = new List <RPBaseItem>();
                    await banco.EditJogadorAsync(jogador);

                    await session.CommitTransactionAsync();

                    await ctx.RespondAsync($"{ctx.User.Mention}, você saiu da torre!");
                }
                else
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, você só pode subir para o céu morrendo!");
                }
            }
        }
예제 #10
0
        public async Task ComandoAtacarAsync(CommandContext ctx, string stringIndexAlvo = "#0")
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            if (personagemNaoModificar.IsPortalAberto)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você não pode usar este comando com o portal aberto!");

                return;
            }

            if (personagemNaoModificar.Zona.Monstros.Count == 0)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você não tem vê monstros para atacar!");

                return;
            }

            // Converte o id informado.
            if (!stringIndexAlvo.TryParseID(out int indexAlvo))
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, o `#ID` precisa ser numérico!");

                return;
            }

            // Inicia uma sessão do Mongo para não ter alteração duplicada.
            using (var session = await banco.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                // Limita o id.
                indexAlvo = Math.Clamp(indexAlvo, 0, personagem.Zona.Monstros.Count - 1);

                StringBuilder resumoBatalha = new StringBuilder();
                bool          monstroMorreu = false;

                // Executa os efeitos ativos no personagem.
                personagem.CalcEfeitos(resumoBatalha);

                // Executa os ataques do inimigo.
                personagem.Zona.CalcAtaquesInimigos(personagem, resumoBatalha);

                // Exibimos a vida/mana do personagem no começo da mensagem.
                DiscordEmbedBuilder embed = new DiscordEmbedBuilder();


                // Verifica se o personagem vai acertar o monstro
                bool chanceAcertoPersonagem = Calculo.DanoFisicoChanceAcerto(personagem.Precisao.Modificado, personagem.Zona.Monstros[indexAlvo].Evasao);
                if (chanceAcertoPersonagem)
                {
                    // Randomizamos um dano médio com base no minimo e max da arma equipada.
                    double danoPersonagem = personagem.DanoFisicoModificado.Sortear;
                    personagem.Zona.Monstros[indexAlvo].Vida -= danoPersonagem;
                    resumoBatalha.AppendLine($"\n{Emoji.Adaga} Você causou {danoPersonagem.Text()} de dano no {personagem.Zona.Monstros[indexAlvo].Nome}!");

                    // Se o monstro morrer.
                    if (personagem.Zona.Monstros[indexAlvo].Vida <= 0)
                    {
                        DiscordEmoji xp = DiscordEmoji.FromGuildEmote(ctx.Client, 758439721016885308);

                        double expGanha = Calculo.CalcularEfetividadeXP(personagem.Nivel.Atual, personagem.Zona.Monstros[indexAlvo].Nivel) * personagem.Zona.Monstros[indexAlvo].Exp;
                        resumoBatalha.AppendLine($"{Emoji.CrossBone} {personagem.Zona.Monstros[indexAlvo].Nome.Bold()} ️{Emoji.CrossBone}\n" +
                                                 $"{xp}+{expGanha.Text()}.");
                        monstroMorreu = true;
                        //Evento halloween
                        int evoluiu = personagem.AddExp(expGanha);
                        if (evoluiu != 0)
                        {
                            embed.AddField("Evolução".Titulo(), $"{Emoji.Up} Você evoluiu de nível!");
                        }

                        // Recarrega os frascos
                        foreach (var item in personagem.Frascos)
                        {
                            item.AddCarga(1);
                        }
                        // Dropa itens
                        personagem.Zona.SortearItem(personagem.Zona.Monstros[indexAlvo], personagem.ChanceDrop);
                    }
                }
                else // Caso ele erre o ataque
                {
                    resumoBatalha.AppendLine($"\n{Emoji.Desapontado} Você errou o ataque!");
                }

                // Informações complementares
                embed.WithDescription($"**Turno {personagem.Zona.Turno}.**\n" +
                                      $"**Inimigo restante {personagem.Zona.Monstros.Count} .**");

                embed.WithColor(DiscordColor.Blue);
                // Se o personagem morrer, reseta ele.
                bool jogadorMorreu = false;
                if (personagem.Vida.Atual <= 0)
                {
                    personagem.Resetar();

                    resumoBatalha.AppendLine($"{Emoji.CrossBone} Você morreu!!! {Emoji.CrossBone}".Bold());
                    embed.WithColor(DiscordColor.Red);
                    embed.WithImageUrl("https://cdn.discordapp.com/attachments/758139402219159562/769397084284649472/kisspng-headstone-drawing-royalty-free-clip-art-5afd7eb3d84cb3.625146071526562483886.png");
                    jogadorMorreu = true;
                }

                // Exibe o resumo da batalha.. Regens e ataques.
                embed.AddField("Resumo da batalha".Titulo(), resumoBatalha.ToString());
                embed.WithAuthor($"{ctx.User.Username} - Nível {personagem.Nivel.Atual} - {personagem.Classe} - {personagem.Nome}", iconUrl: ctx.User.AvatarUrl);
                embed.WithThumbnail("https://cdn.discordapp.com/attachments/758139402219159562/758425473541341214/sword-and-shield-icon-17.png");

                if (personagem.Zona.ItensNoChao.Count != 0)
                {
                    embed.AddField("Itens no chão".Titulo().Bold(), $":mag: {personagem.Zona.ItensNoChao.Count.Bold()} item. ");
                }

                // Adiciona nova onda.
                if (monstroMorreu)
                {
                    if (personagem.Zona.NovaOnda(personagem.VelocidadeAtaque.Modificado, out int inimigosNovos))
                    {
                        embed.AddField("Nova onda".Titulo(), $"{Emoji.ExplacamaoDupla} Apareceu {inimigosNovos} monstros!");
                    }
                }
                if (!jogadorMorreu)
                {
                    var porcentagemVida = personagem.Vida.Atual / personagem.Vida.Maximo;
                    var porcenagemMana  = personagem.Mana.Atual / personagem.Mana.Maximo;
                    embed.AddField($"{"Vida atual".Underline()}", $"{ConverterVida(porcentagemVida)} {(porcentagemVida * 100).Text()}%", true);
                    embed.AddField($"{"Mana atual".Underline()}", $"{ConverterMana(porcenagemMana)} {(porcenagemMana * 100).Text()}%", true);
                }

                // Salvamos.
                await banco.EditJogadorAsync(jogador);

                await session.CommitTransactionAsync();

                await ctx.RespondAsync(ctx.User.Mention, embed : embed.Build());
            }
        }
예제 #11
0
        public async Task ComandoComprarAsync(CommandContext ctx, int quantidade, [RemainingText] string stringItem)
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            if (personagemNaoModificar.Zona.Nivel != 0)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você somente pode comprar itens fora da torre!");

                return;
            }

            if (quantidade <= 0)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você precisa informar uma quantidade maior que 0!");

                return;
            }

            if (string.IsNullOrEmpty(stringItem))
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você precisa informar o nome do item que deseja comprar!");

                return;
            }

            stringItem = StringExtension.RemoverAcentos(stringItem.ToLower());

            // Inicia uma sessão do Mongo para não ter alteração duplicada.
            using (var session = await banco.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;
                bool         vendeu     = false;
                RPBaseItem   item       = null;

                switch (stringItem)
                {
                case "pergaminho de portal":
                case "portal":
                    bool tem = personagem.Mochila.TryRemoveItemCurrency(RPClasse.PergaminhoSabedoria, out RPBaseItem pergaminhoSabedoria, 3 * quantidade);
                    if (tem)
                    {
                        item = new MoedasEmpilhaveis().PergaminhoPortal();
                        for (int i = 0; i < quantidade; i++)
                        {
                            vendeu = personagem.Mochila.TryAddItem(item);
                        }
                    }
                    else
                    {
                        await ctx.RespondAsync($"{ctx.User.Mention}, você não tem {(3 * quantidade).Bold()} {"Pergaminho de Sabedoria".Titulo()} para comprar este item!");

                        return;
                    }
                    break;
                }

                if (vendeu)
                {
                    // Salvamos.
                    await banco.EditJogadorAsync(jogador);

                    await session.CommitTransactionAsync();

                    await ctx.RespondAsync($"{ctx.User.Mention}, você acabou de comprar {quantidade.Bold()} {item.TipoBaseModificado.Titulo()}!");
                }
                else
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, você não tem espaço o suficiente na mochila para comprar este item!");
                }
            }
        }
예제 #12
0
        public async Task ComandoVenderAsync(CommandContext ctx, string stringId = "")
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            // Somente pode vender itens na base. (andar 0)
            if (personagemNaoModificar.Zona.Nivel != 0)
            {
                await ctx.RespondAsync($"{ctx.Member.Mention}, você precisa estar fora da torre para vender itens.");

                return;
            }

            if (string.IsNullOrEmpty(stringId))
            {
                await ctx.RespondAsync($"{ctx.Member.Mention}, você precisa informar um `#ID` de um item para poder estar vendendo. Digite `!mochila` para encontra-los, eles geralmente são os primeiros números de um item!");

                return;
            }

            // Converte o id informado.
            if (!stringId.TryParseID(out int index))
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, o `#ID` é numérico!");

                return;
            }

            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                if (personagem.Mochila.TryRemoveItem(index, out RPBaseItem item))
                {
                    bool adicionou = false;
                    switch (item)
                    {
                    case RPMoedaEmpilhavel me:
                        switch (me.Classe)
                        {
                        case RPClasse.FragmentoPergaminho:
                            await ctx.RespondAsync($"{ctx.User.Mention}, você não pode vender este item!");

                            return;

                        case RPClasse.PergaminhoSabedoria:
                            adicionou = personagem.Mochila.TryAddItem(new MoedasEmpilhaveis().PergaminhoFragmento());
                            break;

                        case RPClasse.PergaminhoPortal:
                            for (int i = 0; i < 3; i++)
                            {
                                adicionou = personagem.Mochila.TryAddItem(new MoedasEmpilhaveis().PergaminhoSabedoria());
                            }
                            break;
                        }
                        break;

                    case RPBaseItem bi:
                        //Verificar a raridade, se for normal, vender por 1 fragmento de pergaminho.
                        switch (bi.Raridade)
                        {
                        case RPRaridade.Normal:
                            adicionou = personagem.Mochila.TryAddItem(new MoedasEmpilhaveis().PergaminhoFragmento());
                            break;
                        }
                        break;
                    }

                    if (adicionou)
                    {
                        await banco.EditJogadorAsync(jogador);

                        await session.CommitTransactionAsync();

                        await ctx.RespondAsync($"{ctx.User.Mention}, você vendeu {1.Bold()} {item.TipoBaseModificado.Titulo()}!");

                        return;
                    }

                    await ctx.RespondAsync($"{ctx.Member.Mention}, você não tem espaço o suficiente na mochila.");

                    return;
                }

                await ctx.RespondAsync($"{ctx.Member.Mention}, não existe item com este `#ID` na mochila.");

                return;
            }
        }
예제 #13
0
        public async Task ComandoEquiparAsync(CommandContext ctx, string stringIndexItem = "0")
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            if (!stringIndexItem.TryParseID(out int indexItem))
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, o `#ID` precisa ser numérico. Digite `!mochila` para encontrar `#ID`s.");

                return;
            }

            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                bool equipou = false;
                // Tenta remover o item
                if (personagem.Mochila.TryRemoveItem(indexItem, out RPBaseItem item))
                {
                    // Verifica se tem o nível suficiente para equipar.
                    if (item.ILevel > personagem.Nivel.Atual)
                    {
                        await ctx.RespondAsync($"{ctx.User.Mention}, o seu personagem não tem o nível {item.ILevel.Bold()} para equipar este item!");

                        return;
                    }

                    // Verifica o tipo do item
                    switch (item.Classe)
                    {
                    case RPClasse.Frasco:
                        #region Frascos
                        // Todas os slots estão equipados?
                        var pocaoEquipada = personagem.Frascos.ElementAtOrDefault(4);
                        if (pocaoEquipada != null)
                        {
                            // Avisa
                            await ctx.RespondAsync($"{ctx.User.Mention}, você precisa retirar um frasco equipados, antes de tentar equipar outro!");

                            return;
                        }

                        // Equipa
                        personagem.Frascos.Add(item as RPBaseFrasco);
                        if (personagem.Zona.Nivel == 0)
                        {
                            (item as RPBaseFrasco).ResetarCargas();
                        }
                        equipou = true;
                        break;

                    case RPClasse.DuasMao:
                        // Verifica se as duas mão estão equipadas
                        if (personagem.MaoPrincipal != null)
                        {
                            // Avisa
                            await ctx.RespondAsync($"{ctx.User.Mention}, este item precisa das duas mãos livres!");

                            return;
                        }

                        if (personagem.MaoSecundaria != null)
                        {
                            // Avisa
                            await ctx.RespondAsync($"{ctx.User.Mention}, este item precisa das duas mãos livres!");

                            return;
                        }

                        // Equipa
                        personagem.Equipar(item);
                        personagem.MaoPrincipal = item;
                        equipou = true;
                        break;

                        #endregion
                    case RPClasse.UmaMao:
                        #region Armas de uma mão
                        // Verificar se a primeira mão está vazias.
                        if (personagem.MaoPrincipal == null)
                        {
                            // Equipa
                            personagem.Equipar(item);
                            personagem.MaoPrincipal = item;
                            equipou = true;
                            break;
                        }
                        // Verifica se a segunda mão está vazia
                        if (personagem.MaoSecundaria == null && personagem.MaoPrincipal.Classe != RPClasse.DuasMao)
                        {
                            // Equipa
                            personagem.Equipar(item);
                            personagem.MaoSecundaria = item;
                            equipou = true;
                            break;
                        }

                        // As duas estão ocupadas? Avisa
                        await ctx.RespondAsync($"{ctx.User.Mention}, as suas duas mãos já estão ocupadas segurando outro item!");

                        return;

                        #endregion
                    default:
                        await ctx.RespondAsync($"{ctx.User.Mention}, este item não é equipável!");

                        return;
                    }
                }
                else
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, `#ID` não encontrado!");

                    return;
                }

                await banco.EditJogadorAsync(jogador);

                await session.CommitTransactionAsync();

                if (equipou)
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, você equipou {item.TipoBaseModificado.Titulo().Bold()}!");
                }
            }
        }
예제 #14
0
        public async Task ComandoPortalAsync(CommandContext ctx)
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            if (personagemNaoModificar.IsPortalAberto)
            {
                // Voltar para zona em que ele estava
                using (var session = await banco.Cliente.StartSessionAsync())
                {
                    BancoSession banco   = new BancoSession(session);
                    RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                    RPPersonagem personagem = jogador.Personagem;

                    personagem.IsPortalAberto = false;
                    personagem.Zona.Nivel     = personagem.Zona.NivelAnterior;
                    await banco.EditJogadorAsync(jogador);

                    await session.CommitTransactionAsync();

                    await ctx.RespondAsync($"{ctx.User.Mention}, portal fechado, você voltou para a zona {personagem.Zona.Nivel}!");
                }
                return;
            }

            if (personagemNaoModificar.Zona.Nivel == 0)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você não pode usar um portal na base!");

                return;
            }

            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                if (personagem.Mochila.TryRemoveItemCurrency(RPClasse.PergaminhoPortal, out RPBaseItem _))
                {
                    personagem.IsPortalAberto = true;

                    personagem.Zona.NivelAnterior = personagem.Zona.Nivel;
                    personagem.Zona.Nivel         = 0;
                    personagem.Vida.Adicionar(double.MaxValue);
                    personagem.Mana.Adicionar(double.MaxValue);

                    await banco.EditJogadorAsync(jogador);

                    await session.CommitTransactionAsync();

                    await ctx.RespondAsync($"{ctx.User.Mention}, portal aberto, você saiu da torre!");
                }
                else
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, você não tem {"Pergaminho de Portal".Titulo()}!");
                }
            }
        }
예제 #15
0
        public async Task ComandoUsarPocaoAsync(CommandContext ctx, string stringId = "0")
        {
            // Verifica se existe o jogador,
            var(naoCriouPersonagem, personagemNaoModificar) = await banco.VerificarJogador(ctx);

            if (naoCriouPersonagem)
            {
                return;
            }

            if (personagemNaoModificar.Zona.Monstros.Count == 0)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você só pode usar poções em batalha.");

                return;
            }

            if (personagemNaoModificar.Frascos.Count == 0)
            {
                await ctx.RespondAsync($"{ctx.User.Mention}, você não tem frascos equipados para usar.");

                return;
            }

            bool usouPocao = false;

            using (var session = await banco.Cliente.StartSessionAsync())
            {
                BancoSession banco   = new BancoSession(session);
                RPJogador    jogador = await banco.GetJogadorAsync(ctx);

                RPPersonagem personagem = jogador.Personagem;

                if (stringId.TryParseID(out int id))
                {
                    id = Math.Clamp(id, 0, personagem.Frascos.Count - 1);

                    if (personagem.Frascos[id].CargasAtual >= personagem.Frascos[id].CargasUso)
                    {
                        switch (personagem.Frascos[id].Classe)
                        {
                        case Enuns.RPClasse.Frasco:
                            usouPocao = true;
                            personagem.Frascos[id].RemoverCarga(personagem.Frascos[id].CargasUso);
                            double duracao = personagem.Frascos[id].Tempo / personagem.VelocidadeAtaque.Modificado;
                            personagem.Efeitos.Add(new RPEfeito(Enuns.RPClasse.Frasco, "Regeneração de vida", duracao, personagem.Frascos[id].Regen / duracao, personagem.VelocidadeAtaque.Modificado));
                            break;

                        default:
                            await ctx.RespondAsync("Frasco não usavel ainda!");

                            return;
                        }
                    }
                    else
                    {
                        await ctx.RespondAsync($"{ctx.User.Mention}, o frasco não tem cargas o suficiente!");

                        return;
                    }

                    await banco.EditJogadorAsync(jogador);

                    await session.CommitTransactionAsync();

                    if (usouPocao)
                    {
                        await ctx.RespondAsync($"{ctx.User.Mention}, você acabou de usar { personagem.Frascos[id].TipoBaseModificado.Titulo().Bold()}!");
                    }
                }
                else
                {
                    await ctx.RespondAsync($"{ctx.User.Mention}, o `#ID` precisa ser numérico. Digite `!equipamentos` para encontrar `#ID`s.");
                }
            }
        }