Exemple #1
0
        public Classe Gerar(Random rnd)
        {
            string[]       atributosEspirituais = new string[] { "Idéia", "Existência" };
            string[]       atributosFisicos     = new string[] { "Força", "Destreza", "Matéria" };
            string[]       atributosMentais     = new string[] { "Intelecto", "Criatividade" };
            string[]       estilos    = new string[] { "Melee", "Ranged", "Caster", "Comando", "Ofício" };
            string[]       funcoes    = new string[] { "Dano", "Cura", "Suporte", "Controle", "Crafting" };
            GeradorInteiro rng        = new GeradorInteiro();
            GeradorString  genString  = new GeradorString();
            GeradorCiencia genCiencia = new GeradorCiencia();
            GeradorPericia genPericia = new GeradorPericia();
            Classe         classe     = new Classe()
            {
                AtributoEspiritual = atributosEspirituais[rng.GerarEntre(0, atributosEspirituais.Length - 1, rnd)],
                AtributoFisico     = atributosFisicos[rng.GerarEntre(0, atributosFisicos.Length - 1, rnd)],
                AtributoMental     = atributosMentais[rng.GerarEntre(0, atributosMentais.Length - 1, rnd)],
                Estilo             = estilos[rng.GerarEntre(0, estilos.Length - 1, rnd)],
                Funcao             = funcoes[rng.GerarEntre(0, funcoes.Length - 1, rnd)],
                Nome        = genString.GerarTamanhoEspecifico(4, 8, rnd),
                OrigemPoder = genString.GerarTamanhoEspecifico(4, 8, rnd),
                Ciencia     = genCiencia.Gerar(rnd),
                Pericias    = genPericia.GerarLista(rng.GerarEntre(1, 5, rnd), rnd)
            };

            classe.Descricao = "Classe de estilo " + classe.Estilo + ", utilizando " + classe.AtributoFisico + ", " + classe.AtributoEspiritual + " e " + classe.AtributoMental + ", com a função principal de " + classe.Funcao + " gerada aleatoriamente.";

            return(classe);
        }
Exemple #2
0
        public ValorMag GerarEntre(ValorMag min, ValorMag max, Random rnd)
        {
            GeradorInteiro rng   = new GeradorInteiro();
            int            valor = 1;
            int            mag   = rng.GerarEntre(min.Magnitude, max.Magnitude, rnd);

            if (mag == min.Magnitude)
            {
                if (mag == max.Magnitude)
                {
                    valor = rng.GerarEntre(min.Valor, max.Valor, rnd);
                }
                else
                {
                    valor = rng.GerarEntre(min.Valor, 99, rnd);
                }
            }
            else if (mag == max.Magnitude)
            {
                valor = rng.GerarEntre(10, max.Valor, rnd);
            }
            else
            {
                valor = rng.GerarEntre(10, 99, rnd);
            }

            ValorMag resultado = new ValorMag(valor, mag);

            return(resultado);
        }
Exemple #3
0
        public Equipamento Gerar(Random rnd)
        {
            GeradorInteiro rng = new GeradorInteiro();
            //Quantidade de tipos diferentes de equipamento existentes
            int quantidadeTiposEquipamento = 3;

            int tipoDeEquipamento = rng.GerarEntre(1, quantidadeTiposEquipamento, rnd);

            switch (tipoDeEquipamento)
            {
            //ArmaBranca
            case 1:
                GeradorArmaBranca genArmaBranca = new GeradorArmaBranca();
                return(genArmaBranca.Gerar(rnd));

            //ArmaDeTiro
            case 2:
                GeradorArmaDeTiro genArmaDeTiro = new GeradorArmaDeTiro();
                return(genArmaDeTiro.Gerar(rnd));

            //Vestivel
            case 3:
                GeradorVestivel genVestivel = new GeradorVestivel();
                return(genVestivel.Gerar(rnd));

            default:
                return(null);
            }
        }
Exemple #4
0
        public Evolucao Gerar(Random rnd)
        {
            GeradorInteiro rng = new GeradorInteiro();
            GeradorBoolean rbg = new GeradorBoolean();

            return(new Evolucao(rng.GerarEntre(1, 17, rnd), 16, rbg.GeraComChance(10, rnd)));
        }
Exemple #5
0
        public Consumivel Gerar(Random rnd)
        {
            GeradorInteiro  rng         = new GeradorInteiro();
            GeradorValorMag genValorMag = new GeradorValorMag();
            GeradorMaterial genMaterial = new GeradorMaterial();
            GeradorString   genString   = new GeradorString();
            GeradorEfeito   genEfeito   = new GeradorEfeito();
            Consumivel      resultado   = new Consumivel()
            {
                Id = rng.GerarEntre(1, 1000, rnd),
                Caracteristicas = "Consumivel gerado aleatoriamente",
                Comprimento     = genValorMag.Gerar(rnd),
                Essencia        = rng.GerarEntre(1, 100000, rnd),
                Energia         = rng.GerarEntre(0, 100000, rnd),
                Largura         = genValorMag.Gerar(rnd),
                MaterialBase    = genMaterial.Gerar(rnd),
                Nivel           = rng.GerarEntre(1, 100, rnd),
                Nome            = genString.GerarTamanhoEspecifico(3, 8, rnd),
                Peso            = genValorMag.Gerar(rnd),
                Raridade        = rng.GerarEntre(1, 100, rnd),
                Tipo            = rng.GerarEntre(1, 100, rnd),
                Valor           = rng.GerarEntre(1, 100000, rnd),
                Magnitude       = rng.GerarEntre(1, 20, rnd),
                Massa           = genValorMag.Gerar(rnd),
                Efeitos         = genEfeito.GerarLista(rng.GerarEntre(1, 5, rnd), rnd)
            };

            return(resultado);
        }
Exemple #6
0
        public Municao Gerar(Random rnd)
        {
            GeradorInteiro     rng            = new GeradorInteiro();
            GeradorValorMag    genValorMag    = new GeradorValorMag();
            GeradorMaterial    genMaterial    = new GeradorMaterial();
            GeradorString      genString      = new GeradorString();
            GeradorModificador genModificador = new GeradorModificador();
            Municao            resultado      = new Municao()
            {
                Id = rng.GerarEntre(1, 1000, rnd),
                Caracteristicas = "Munição gerada aleatoriamente",
                Comprimento     = genValorMag.Gerar(rnd),
                Essencia        = rng.GerarEntre(1, 100000, rnd),
                Energia         = rng.GerarEntre(0, 100000, rnd),
                Largura         = genValorMag.Gerar(rnd),
                MaterialBase    = genMaterial.Gerar(rnd),
                Nivel           = rng.GerarEntre(1, 100, rnd),
                Nome            = genString.GerarTamanhoEspecifico(3, 8, rnd),
                Peso            = genValorMag.Gerar(rnd),
                Raridade        = rng.GerarEntre(1, 100, rnd),
                Tipo            = rng.GerarEntre(1, 100, rnd),
                Valor           = rng.GerarEntre(1, 100000, rnd),
                Magnitude       = rng.GerarEntre(1, 20, rnd),
                Massa           = genValorMag.Gerar(rnd),
                CorteBonus      = genValorMag.Gerar(rnd),
                DanoBonus       = genValorMag.Gerar(rnd),
                ImpactoBonus    = genValorMag.Gerar(rnd),
                PenetracaoBonus = genValorMag.Gerar(rnd)
            };

            resultado.Modificadores = genModificador.GerarListaComOrigem("Munição", resultado.Id, rng.GerarEntre(0, 5, rnd), rnd);

            return(resultado);
        }
Exemple #7
0
        public IEfeito Gerar(Random rnd)
        {
            GeradorInteiro           rng           = new GeradorInteiro();
            GeradorEfeitoDano        genEfeitoDano = new GeradorEfeitoDano();
            GeradorEfeitoCura        genEfeitoCura = new GeradorEfeitoCura();
            GeradorEfeitoModificador genEfeitoMod  = new GeradorEfeitoModificador();
            int tipo = rng.GerarEntre(1, 3, rnd);

            switch (tipo)
            {
            //Dano
            case 1:
                return(genEfeitoDano.Gerar(rnd));

            //Cura
            case 2:
                return(genEfeitoCura.Gerar(rnd));

            //Modificador
            case 3:
                return(genEfeitoMod.Gerar(rnd));

            default:
                return(null);
            }
        }
        public Habilidade Gerar(Random rnd)
        {
            //TODO: Pegar aleatoriamente do banco de dados de habilidades
            //TODO: Pegar Pericia Associada do banco de dados de pericias
            //TODO: Criar efeitos secundários. Ex: dano + buff, cura +  piora, etc

            //TODO: Restringir o tipo da Habilidade por uma lista do banco de dados
            GeradorInteiro          rng                 = new GeradorInteiro();
            GeradorString           genString           = new GeradorString();
            GeradorPericia          genPericia          = new GeradorPericia();
            GeradorEnergia          genEnergia          = new GeradorEnergia();
            GeradorValorMag         genValorMag         = new GeradorValorMag();
            GeradorAreaCientifica   genAreaCientifica   = new GeradorAreaCientifica();
            GeradorTipoDeAlvo       genTipoDeAlvo       = new GeradorTipoDeAlvo();
            GeradorEfeito           genEfeito           = new GeradorEfeito();
            GeradorTipoDeHabilidade genTipoDeHabilidade = new GeradorTipoDeHabilidade();

            Habilidade habilidade = new Habilidade()
            {
                Id               = rng.GerarEntre(1, 1000, rnd),
                Magnitude        = rng.GerarEntre(1, 10, rnd),
                Nome             = genString.GerarTamanhoEspecifico(2, 8, rnd),
                PericiaAssociada = genPericia.Gerar(rnd),
                Energia          = genEnergia.Gerar(rnd),
                AreaCientifica   = genAreaCientifica.Gerar(rnd),
                Efeitos          = genEfeito.GerarLista(rng.GerarEntre(1, 3, rnd), rnd),
                Tipo             = genTipoDeHabilidade.Gerar(rnd)
            };

            habilidade.Caracteristicas = "Habilidade gerada automaticamente.";

            return(habilidade);
        }
Exemple #9
0
        ///<summary>
        ///Gera um ValorMag aleatório entre 10m0 e 99m20
        ///</summary>
        public ValorMag Gerar(Random rnd)
        {
            GeradorInteiro rng   = new GeradorInteiro();
            int            valor = rng.GerarEntre(10, 99, rnd);
            int            mag   = rng.GerarEntre(0, 20, rnd);

            return(new ValorMag(valor, mag));
        }
Exemple #10
0
        public Carisma Gerar(Random rnd)
        {
            GeradorInteiro rng     = new GeradorInteiro();
            Carisma        carisma = new Carisma()
            {
                Negativo = rng.GerarEntre(0, 100, rnd),
                Neutro   = rng.GerarEntre(0, 100, rnd),
                Positivo = rng.GerarEntre(0, 100, rnd)
            };

            return(carisma);
        }
        public TipoHabilidade Gerar(Random rnd)
        {
            GeradorString  genString = new GeradorString();
            GeradorInteiro rng       = new GeradorInteiro();

            TipoHabilidade resultado = new TipoHabilidade()
            {
                Id   = rng.GerarEntre(1, 100, rnd),
                Nome = genString.GerarTamanhoEspecifico(4, 10, rnd)
            };

            return(resultado);
        }
Exemple #12
0
        public Destino Gerar(Random rnd)
        {
            GeradorInteiro rng     = new GeradorInteiro();
            Destino        destino = new Destino()
            {
                Acaso    = rng.GerarEntre(0, 100, rnd),
                Azar     = rng.GerarEntre(0, 100, rnd),
                Desgraca = rng.GerarEntre(0, 100, rnd),
                Milagre  = rng.GerarEntre(0, 100, rnd),
                Sorte    = rng.GerarEntre(0, 100, rnd)
            };

            return(destino);
        }
Exemple #13
0
        public Item Gerar(Random rnd)
        {
            GeradorInteiro rng = new GeradorInteiro();
            //Número de tipos de item diferentes. Utilizado para aleatorizar o tipo de item a ser gerado. Adicionar mais um a cada novo tipo de item adicionado
            int quantidadeTiposDeItem = 7;

            int tipoDeItem = rng.GerarEntre(1, quantidadeTiposDeItem, rnd);

            switch (tipoDeItem)
            {
            //ArmaBranca
            case 1:
                GeradorArmaBranca genArmaBranca = new GeradorArmaBranca();
                return(genArmaBranca.Gerar(rnd));

            //ArmaDeTiro
            case 2:
                GeradorArmaDeTiro genArmaDeTiro = new GeradorArmaDeTiro();
                return(genArmaDeTiro.Gerar(rnd));

            //Consumivel
            case 3:
                GeradorConsumivel genConsumivel = new GeradorConsumivel();
                return(genConsumivel.Gerar(rnd));

            //Material
            case 4:
                GeradorMaterial genMaterial = new GeradorMaterial();
                return(genMaterial.Gerar(rnd));

            //Municao
            case 5:
                GeradorMunicao genMunicao = new GeradorMunicao();
                return(genMunicao.Gerar(rnd));

            //Posse
            case 6:
                GeradorPosse genPosse = new GeradorPosse();
                return(genPosse.Gerar(rnd));

            //Vestivel
            case 7:
                GeradorVestivel genVestivel = new GeradorVestivel();
                return(genVestivel.Gerar(rnd));

            default:
                return(null);
            }
        }
Exemple #14
0
        public EfeitoModificador Gerar(Random rnd)
        {
            GeradorInteiro       rng            = new GeradorInteiro();
            GeradorDuracaoEfeito genDuracao     = new GeradorDuracaoEfeito();
            GeradorModificador   genModificador = new GeradorModificador();
            GeradorTipoDeAlvo    genTipoDeAlvo  = new GeradorTipoDeAlvo();
            EfeitoModificador    resultado      = new EfeitoModificador()
            {
                Duracao     = genDuracao.Gerar(rnd),
                Modificador = genModificador.Gerar(rnd),
                TipoDeAlvo  = genTipoDeAlvo.Gerar(rnd)
            };

            return(resultado);
        }
Exemple #15
0
        public Natureza Gerar(Random rnd)
        {
            GeradorInteiro rng = new GeradorInteiro();

            Natureza resultado = new Natureza()
            {
                Apresentacao  = rng.GerarEntre(1, 26, rnd),
                Concepcao     = rng.GerarEntre(1, 26, rnd),
                Honra         = rng.GerarEntre(1, 26, rnd),
                Moral         = rng.GerarEntre(1, 26, rnd),
                Percepcao     = rng.GerarEntre(1, 26, rnd),
                Personalidade = rng.GerarEntre(1, 26, rnd)
            };

            return(resultado);
        }
Exemple #16
0
        public Energia Gerar(Random rnd)
        {
            //TODO: pegar uma energia a partir do banco de dados
            List <String> tiposEnergia = new List <string> {
                "AP", "CP", "EP", "HP", "MP", "QP", "SP", "PE", "PA", "WP"
            };
            GeradorInteiro rng = new GeradorInteiro();

            Energia energia = new Energia()
            {
                Sigla      = tiposEnergia[rng.GerarEntre(0, tiposEnergia.Count - 1, rnd)],
                Quantidade = rng.GerarEntre(1, 1000000, rnd)
            };

            return(energia);
        }
Exemple #17
0
        public Resposta Gerar(Random rnd)
        {
            GeradorInteiro rng      = new GeradorInteiro();
            Resposta       resposta = new Resposta()
            {
                Bravura     = rng.GerarEntre(1, 1000, rnd),
                Coragem     = rng.GerarEntre(1, 1000, rnd),
                Desespero   = rng.GerarEntre(1, 1000, rnd),
                Heroismo    = rng.GerarEntre(1, 1000, rnd),
                Indiferenca = rng.GerarEntre(1, 1000, rnd),
                Medo        = rng.GerarEntre(1, 1000, rnd),
                Panico      = rng.GerarEntre(1, 1000, rnd)
            };

            return(resposta);
        }
Exemple #18
0
        public EfeitoCura Gerar(Random rnd)
        {
            GeradorInteiro       rng           = new GeradorInteiro();
            GeradorValorMag      genValorMag   = new GeradorValorMag();
            GeradorDuracaoEfeito genDuracao    = new GeradorDuracaoEfeito();
            GeradorEnergia       genEnergia    = new GeradorEnergia();
            GeradorTipoDeAlvo    genTipoDeAlvo = new GeradorTipoDeAlvo();
            EfeitoCura           resultado     = new EfeitoCura()
            {
                Duracao     = genDuracao.Gerar(rnd),
                EnergiaAlvo = genEnergia.Gerar(rnd),
                TipoDeAlvo  = genTipoDeAlvo.Gerar(rnd),
                Valor       = genValorMag.Gerar(rnd)
            };

            return(resultado);
        }
        public DuracaoEfeito Gerar(Random rnd)
        {
            GeradorInteiro rng = new GeradorInteiro();


            List <string> tiposDuracao = new List <String>()
            {
                "Limitado",
                "Canal",
                "Marca",
                "Postura",
                "Permanente",
                "Instantâneo"
            };

            List <string> unidadesDuracao = new List <string>()
            {
                "Turnos",
                "Segundos",
                "Minutos",
                "Horas",
                "Dias",
                "Meses",
                "Anos",
                "Séculos",
                "Milênios",
                "Gêneses"
            };

            DuracaoEfeito resultado = new DuracaoEfeito()
            {
                TipoDuracao = tiposDuracao[rng.GerarEntre(0, tiposDuracao.Count - 1, rnd)],
            };

            if (resultado.TipoDuracao == "Limitado")
            {
                GeradorValorMag genValorMag = new GeradorValorMag();
                resultado.UnidadeDuracao = unidadesDuracao[rng.GerarEntre(0, unidadesDuracao.Count - 1, rnd)];
                resultado.ValorDuracao   = genValorMag.Gerar(rnd);
            }
            return(resultado);
        }
        public Resistencia Gerar(Random rnd)
        {
            GeradorInteiro   rng         = new GeradorInteiro();
            GeradorValorMag  genValorMag = new GeradorValorMag();
            GeradorBoolean   genBoolean  = new GeradorBoolean();
            GeradorString    genString   = new GeradorString();
            CalculadorNumero calculador  = new CalculadorNumero();
            Resistencia      resultado   = new Resistencia();
            ValorMag         min         = genValorMag.GerarEntre(new ValorMag(10, 0), new ValorMag(99, 10), rnd);
            ValorMag         max         = calculador.SomaValorMag(min, genValorMag.GerarEntre(new ValorMag(10, 0), new ValorMag(99, 10), rnd));

            char tipo;

            if (genBoolean.GeraComChance(50, rnd))
            {
                tipo = '+';
            }
            else
            {
                tipo = '-';
            }

            resultado.Nome = genString.GerarTamanhoEspecifico(3, 10, rnd);

            if (tipo == '+')
            {
                resultado.Positiva = genValorMag.GerarEntre(min, max, rnd);
                resultado.Negativa = new ValorMag();
            }
            else
            {
                resultado.Positiva = new ValorMag();
                resultado.Negativa = genValorMag.GerarEntre(min, max, rnd);
            }

            return(resultado);
        }
Exemple #21
0
        public Arma Gerar(Random rnd)
        {
            GeradorInteiro rng = new GeradorInteiro();
            //Quantidade de tipos diferentes de equipamento existentes
            int quantidadeTiposArma = 2;

            int tipoDeArma = rng.GerarEntre(1, quantidadeTiposArma, rnd);

            switch (tipoDeArma)
            {
            //ArmaBranca
            case 1:
                GeradorArmaBranca genArmaBranca = new GeradorArmaBranca();
                return(genArmaBranca.Gerar(rnd));

            //ArmaDeTiro
            case 2:
                GeradorArmaDeTiro genArmaDeTiro = new GeradorArmaDeTiro();
                return(genArmaDeTiro.Gerar(rnd));

            default:
                return(null);
            }
        }
        public Modificador GerarComOrigem(string origem, int id, Random rnd, char tipo = 'R')
        {
            GeradorInteiro    rng           = new GeradorInteiro();
            GeradorValorMag   rvmg          = new GeradorValorMag();
            GeradorPericia    genPericia    = new GeradorPericia();
            GeradorHabilidade genHabilidade = new GeradorHabilidade();
            int tipoModificador             = rng.GerarEntre(1, 10, rnd);

            PropertyInfo[] propriedades = typeof(Ser).GetTypeInfo().DeclaredProperties.Where(p => p.PropertyType == typeof(int)).ToArray <PropertyInfo>();
            string         alvo         = propriedades[rng.GerarEntre(0, propriedades.Count() - 1, rnd)].Name;

            switch (tipoModificador)
            {
            case 1:
                ModSomaValorMag modSomaValorMag = new ModSomaValorMag()
                {
                    Alvo   = alvo,
                    Origem = origem,
                    Valor  = rvmg.GerarEntre(new ValorMag(10, 1), new ValorMag(99, 10), rnd)
                };
                return(modSomaValorMag);

            case 2:
                ModSubtraiValorMag modSubtraiValorMag = new ModSubtraiValorMag()
                {
                    Alvo   = alvo,
                    Origem = origem,
                    Valor  = rvmg.GerarEntre(new ValorMag(10, 1), new ValorMag(99, 10), rnd)
                };
                return(modSubtraiValorMag);

            case 3:
                ModSomaNumero modSomaNumero = new ModSomaNumero()
                {
                    Alvo   = alvo,
                    Origem = origem,
                    Valor  = rng.GerarEntre(1, 10000, rnd)
                };
                return(modSomaNumero);

            case 4:
                ModSubtraiNumero modSubtraiNumero = new ModSubtraiNumero()
                {
                    Alvo   = alvo,
                    Origem = origem,
                    Valor  = rng.GerarEntre(1, 10000, rnd)
                };
                return(modSubtraiNumero);

            case 5:
                ModMultiplicaNumero modMultiplicaNumero = new ModMultiplicaNumero()
                {
                    Alvo   = alvo,
                    Origem = origem,
                    Valor  = rng.GerarEntre(1, 10000, rnd)
                };
                return(modMultiplicaNumero);

            case 6:
                ModMultiplicaValorMag modMultiplicaValorMag = new ModMultiplicaValorMag()
                {
                    Alvo   = alvo,
                    Origem = origem,
                    Valor  = rvmg.GerarEntre(new ValorMag(10, 1), new ValorMag(99, 10), rnd)
                };
                return(modMultiplicaValorMag);

            case 7:
                ModDivideNumero modDivideNumero = new ModDivideNumero()
                {
                    Alvo   = alvo,
                    Origem = origem,
                    Valor  = rng.GerarEntre(1, 100, rnd)
                };
                return(modDivideNumero);

            case 8:
                ModDivideValorMag modDivideValorMag = new ModDivideValorMag()
                {
                    Alvo   = alvo,
                    Origem = origem,
                    Valor  = rvmg.GerarEntre(new ValorMag(10, 1), new ValorMag(99, 5), rnd)
                };
                return(modDivideValorMag);

            case 9:
                ModAdicionaHabilidade modAdicionaHabilidade = new ModAdicionaHabilidade()
                {
                    Alvo   = genHabilidade.Gerar(rnd),
                    Origem = origem
                };
                return(modAdicionaHabilidade);

            case 10:
                ModAdicionaPericia modAdicionaPericia = new ModAdicionaPericia()
                {
                    Alvo   = genPericia.Gerar(rnd),
                    Origem = origem
                };
                return(modAdicionaPericia);

            default:
                return(null);
            }
        }
Exemple #23
0
        public ArmaDeTiro Gerar(Random rnd)
        {
            GeradorInteiro     rng            = new GeradorInteiro();
            GeradorValorMag    genValorMag    = new GeradorValorMag();
            GeradorMaterial    genMaterial    = new GeradorMaterial();
            GeradorString      genString      = new GeradorString();
            GeradorMunicao     genMunicao     = new GeradorMunicao();
            GeradorModificador genModificador = new GeradorModificador();
            GeradorBoolean     genBoolean     = new GeradorBoolean();
            int tipoDano = rng.GerarEntre(1, 4, rnd);

            string[]   tiposOperacao = new string[] { "FullAuto", "Burst", "Single", "Pump", "Charge" };
            int        operacoes     = 0;
            ArmaDeTiro armaDeFogo    = new ArmaDeTiro()
            {
                Id = rng.GerarEntre(1, 1000, rnd),
                Caracteristicas = "Arma de Fogo gerada aleatoriamente",
                Comprimento     = genValorMag.Gerar(rnd),
                DistanciaMax    = genValorMag.Gerar(rnd),
                DistanciaMin    = genValorMag.Gerar(rnd),
                Essencia        = rng.GerarEntre(1, 100000, rnd),
                Energia         = rng.GerarEntre(0, 100000, rnd),
                Largura         = genValorMag.Gerar(rnd),
                MaterialBase    = genMaterial.Gerar(rnd),
                Nivel           = rng.GerarEntre(1, 100, rnd),
                Nome            = genString.GerarTamanhoEspecifico(3, 8, rnd),
                Peso            = genValorMag.Gerar(rnd),
                Raridade        = rng.GerarEntre(1, 100, rnd),
                Tipo            = rng.GerarEntre(1, 100, rnd),
                TipoCarga       = genMunicao.Gerar(rnd),
                TirosPorCarga   = rng.GerarEntre(1, 100000, rnd),
                Valor           = rng.GerarEntre(1, 100000, rnd),
            };

            armaDeFogo.Modificadores = genModificador.GerarListaComOrigem("Arma", armaDeFogo.Id, rng.GerarEntre(0, 5, rnd), rnd);

            operacoes = rng.GerarEntre(1, tiposOperacao.Length, rnd);
            for (int i = 0; i < operacoes; i++)
            {
                armaDeFogo.Operacoes    = new string[tiposOperacao.Length];
                armaDeFogo.Operacoes[i] = tiposOperacao[rng.GerarEntre(0, tiposOperacao.Length - 1, rnd)];
            }

            if (tipoDano == 1)
            {
                armaDeFogo.DanoCorte = rng.GerarEntre(1, 100000, rnd);
            }
            else if (tipoDano == 2)
            {
                armaDeFogo.DanoImpacto = rng.GerarEntre(1, 100000, rnd);
            }
            else if (tipoDano == 3)
            {
                armaDeFogo.DanoPenetracao = rng.GerarEntre(1, 1000000, rnd);
            }
            if (genBoolean.GeraComChance(10, rnd))
            {
                armaDeFogo.ModificadorDano = "por ki";
            }

            armaDeFogo.TirosPorAcao = armaDeFogo.TirosPorCarga - rng.GerarEntre(0, 100000, rnd);

            return(armaDeFogo);
        }
Exemple #24
0
        public Ser Gerar(Random rnd)
        {
            //TODO: Pegar valores aleatórios do banco de dados ao invés de gera-los aleatoriamente
            //TODO: Restringir o tempo baseado nas restrições de tempo da espécie selecionada
            GeradorString       genString       = new GeradorString();
            GeradorValorMag     genValorMag     = new GeradorValorMag();
            GeradorInteiro      rng             = new GeradorInteiro();
            GeradorCriatividade genCriatividade = new GeradorCriatividade();
            GeradorDestreza     genDestreza     = new GeradorDestreza();
            GeradorExistencia   genExistencia   = new GeradorExistencia();
            GeradorForca        genForca        = new GeradorForca();
            GeradorIdeia        genIdeia        = new GeradorIdeia();
            GeradorIntelecto    genIntelecto    = new GeradorIntelecto();
            GeradorMateria      genMateria      = new GeradorMateria();
            GeradorOrigem       genOrigem       = new GeradorOrigem();
            GeradorEspecie      genEspecie      = new GeradorEspecie();
            GeradorClasse       genClasse       = new GeradorClasse();
            GeradorIndole       genIndole       = new GeradorIndole();
            GeradorRei          genRei          = new GeradorRei();
            GeradorPericia      genPericia      = new GeradorPericia();
            GeradorItem         genItem         = new GeradorItem();
            GeradorModificador  genModificador  = new GeradorModificador();
            GeradorResistencia  genResistencia  = new GeradorResistencia();
            GeradorEquipamento  genEquipamento  = new GeradorEquipamento();
            GeradorHabilidade   genHabilidade   = new GeradorHabilidade();
            GeradorEvolucao     genEvolucao     = new GeradorEvolucao();
            GeradorEnergia      genEnergia      = new GeradorEnergia();
            CalculadorSer       calculador      = new CalculadorSer();

            string primeiroNome = genString.GerarTamanhoEspecifico(2, 6, rnd);
            string segundoNome  = genString.GerarTamanhoEspecifico(0, 9, rnd);

            Ser ser = new Ser()
            {
                Origem = genOrigem.Gerar(rnd),
                Tempo  = rng.GerarEntre(1, 1000, rnd),
                //Reverter alteração para gerar mais de uma espécie quando a interface de espécies estiver criada
                Especies = genEspecie.GerarLista(rng.GerarEntre(1, 1, rnd), rnd),
                Classes  = genClasse.GerarLista(rng.GerarEntre(1, 3, rnd), rnd),
                Indole   = genIndole.Gerar(rnd),
                Reis     = genRei.GerarLista(rng.GerarEntre(0, 5, rnd), rnd),
                Ki       = rng.GerarEntre(0, 1000, rnd),
                Nivel    = rng.GerarEntre(0, 1000, rnd),
                //Atributos
                Forca        = genForca.Gerar(rnd),
                Materia      = genMateria.Gerar(rnd),
                Destreza     = genDestreza.Gerar(rnd),
                Intelecto    = genIntelecto.Gerar(rnd),
                Criatividade = genCriatividade.Gerar(rnd),
                Existencia   = genExistencia.Gerar(rnd),
                Ideia        = genIdeia.Gerar(rnd),
                //Evolução
                EvolucaoCriatividade = genEvolucao.Gerar(rnd),
                EvolucaoDestreza     = genEvolucao.Gerar(rnd),
                EvolucaoExistencia   = genEvolucao.Gerar(rnd),
                EvolucaoForca        = genEvolucao.Gerar(rnd),
                EvolucaoIdeia        = genEvolucao.Gerar(rnd),
                EvolucaoIntelecto    = genEvolucao.Gerar(rnd),
                EvolucaoMateria      = genEvolucao.Gerar(rnd),
                //Perícias
                Pericias = genPericia.GerarLista(rng.GerarEntre(1, 20, rnd), rnd),
                //Itens e Equips
                Posses = genItem.GerarLista(rng.GerarEntre(1, 20, rnd), rnd),
                //Virtudes
                Dons = genModificador.GerarListaComOrigem("Virtudes", 3, rng.GerarEntre(1, 5, rnd), rnd, '+'),
                //Defeitos
                Defeitos = genModificador.GerarListaComOrigem("Defeitos", 6, rng.GerarEntre(1, 5, rnd), rnd, '-'),
                //Resistências
                Resistencias = genResistencia.GerarLista(rng.GerarEntre(0, 10, rnd), rnd),
                //Gênese
                Genese = rng.GerarEntre(1, 5, rnd),
                //Geração
                Geracao = rng.GerarEntre(1, 10, rnd),
                //Trajetória
                Trajetoria = "Trajetória Gerada Aleatóriamente",
                //Elo Divino
                EloDivino = "Elo Divino Gerado Aleatóriamente",
                //Idumentária
                Idumentaria = "Idumentária gerada aleatoriamente",
                //Subatributo Subatributos Extra
                SubatributoExtraNome1  = genString.GerarTamanhoEspecifico(3, 10, rnd),
                SubatributoExtraValor1 = genValorMag.Gerar(rnd),
                SubatributoExtraNome2  = genString.GerarTamanhoEspecifico(3, 10, rnd),
                SubatributoExtraValor2 = genValorMag.Gerar(rnd),
                //Habilidades
                Habilidades = genHabilidade.GerarLista(rng.GerarEntre(2, 10, rnd), rnd),
                //Alma
                Alma = genString.GerarLista(5, rnd)
            };

            //Itens Equipados
            ser.Equipamentos = genEquipamento.GerarLista(ser.Especies[0].MaxItensEquipados, rnd);

            //Geradores
            //Identidade
            if (segundoNome.Length == 0)
            {
                ser.Nome = primeiroNome;
            }
            else
            {
                ser.Nome = primeiroNome + " " + segundoNome;
            }

            //Calcula outros valores
            ser = calculador.CalculaSer(ser);

            return(ser);
        }