예제 #1
0
 public void ExibirRelatorio()
 {
     Console.Write("Carro -> ");
     CarroPercurso.Veiculo.MostrarVeiculo();
     Console.Write("Percurso -> ");
     CarroPercurso.Percurso.MostrarPercurso();
     Console.Write($"KM Percorridos: {KmPercorrida}\nQuantidade de abastecimentos: {QtdAbastecimentos}\nQuantidade de calibragens: {QtdCalibragens}\nLitros consumidos: {LitrosConsumidos}");
     Console.WriteLine($"\nDesgaste do Pneu:\n{DesgastePneu.ToString()}");
     Console.WriteLine($"Alteracao climatica:\n{AlteracaoClimatica.ToString()}");
 }
예제 #2
0
        public static void CalibrarPneu(Relatorio Relatorio)
        {
            DesgastePneu desgaste = Relatorio.StatusPneu.ElementAt(Relatorio.StatusPneu.Count - 1);
            string       tipoStatus, statusPneu;
            double       multiplicador;

            do
            {
                Console.WriteLine($"\nO status atual do pneu é {desgaste.TipoStatus}");
                Console.WriteLine("Deseja alterar o status do Pneu para qual das opções abaixo:");
                Console.WriteLine("\n3) Novo");
                Console.WriteLine("2) Pouco Desgastado");
                Console.WriteLine("1) Desgastado");
                Console.Write("\nStatus desejado: ");
                statusPneu = Console.ReadLine().Trim();

                if (!Validacao.ValidaStatusPneu(statusPneu))
                {
                    MensagensComDelay.MensagemStatusPneuInvalida();
                }
            } while (!Validacao.ValidaStatusPneu(statusPneu));

            if (desgaste.StatusAtualDoPneu == int.Parse(statusPneu))
            {
                MensagensComDelay.MensagemPneuNaoCalibrou();
                return;
            }

            else if (statusPneu == "3")
            {
                tipoStatus    = "novo";
                multiplicador = 0;
            }

            else if (statusPneu == "2")
            {
                tipoStatus    = "pouco desgastado";
                multiplicador = 0.0725;
            }

            else
            {
                tipoStatus    = "desgastado";
                multiplicador = 0.0915;
            }

            Relatorio.StatusPneu.Add(new DesgastePneu(desgaste.DistanciaDaOcorrencia, multiplicador, 0, int.Parse(statusPneu), tipoStatus));
            Relatorio.QuantidadeCalibragem++;
            MensagensComDelay.MensagemPneuCalibrado();
        }
예제 #3
0
        public static int DesgasteDoPneu() => new Random().Next(0, 2);//Desgaste randomico do pneu.

        public static void ObtemDistanciaASerPercorrida(Relatorio Relatorio, string automatico)
        {
            //Foram preenchidos dois objetos que são auxiliares para os calculos, eles recebem os ultimos elementos da lista.
            DesgastePneu     desgaste = Relatorio.StatusPneu.ElementAt(Relatorio.StatusPneu.Count - 1);
            MudancaClimatica clima    = Relatorio.Clima.ElementAt(Relatorio.Clima.Count - 1);

            //Utilizando uma variavel auxiliar de AutonomiaGasolina e de AutonomiaAlcool, é possível calcular a distancia máxima que o carro pode percorrer atualmente.
            double AutonomiaGasolina = RetornaAutonomiaGasolina(Relatorio, desgaste.MultiplicadorPneu, clima.MultiplicadorClima);
            double AutonomiaAlcool   = RetornaAutonomiaAlcool(Relatorio, desgaste.MultiplicadorPneu, clima.MultiplicadorClima);
            double distanciaMaxima   = Math.Round(Math.Round(AutonomiaGasolina * Relatorio.VeiculoNaEstrada.Veiculo.QuantidadeGasolina, 10) + Math.Round(AutonomiaAlcool * Relatorio.VeiculoNaEstrada.Veiculo.QuantidadeAlcool, 10), 10);
            string distancia;

            //Ajusta a distancia máxima de acordo com o tamanho da viagem, caso o carro possa percorrer mais do q a quantidade q falta para terminar a viagem, ele reduz a distancia para o resto da viagem.
            if (distanciaMaxima > Math.Round(Relatorio.VeiculoNaEstrada.Viagem.DistanciaTotal - Relatorio.KilometrosPercorridos, 10))
            {
                distanciaMaxima = Math.Round(Relatorio.VeiculoNaEstrada.Viagem.DistanciaTotal - Relatorio.KilometrosPercorridos, 10);
            }

            if (automatico == "S")
            {
                distancia = distanciaMaxima.ToString();
                Percorrer(Relatorio, distanciaMaxima, double.Parse(distancia), AutonomiaGasolina, AutonomiaAlcool, desgaste, clima);
            }

            else
            {
                do
                {
                    Console.WriteLine($"\nA viagem tem {Relatorio.VeiculoNaEstrada.Viagem.DistanciaTotal} km, e foram percorridos {Relatorio.KilometrosPercorridos}km.");
                    Console.WriteLine($"A distancia máxima que pode ser percorrida atualmente é {distanciaMaxima}Km.");
                    Console.Write("\nDigite a distancia que gostaria de percorrer em Km: ");
                    distancia = Console.ReadLine().Trim();
                } while (!Validacao.ValidaDistancia(distancia, distanciaMaxima));

                Percorrer(Relatorio, distanciaMaxima, double.Parse(distancia), AutonomiaGasolina, AutonomiaAlcool, desgaste, clima);
            }
        }
예제 #4
0
        public static void Percorrer(Relatorio Relatorio, double distanciaMaxima, double distancia, double AutonomiaGasolina, double AutonomiaAlcool, DesgastePneu desgaste, MudancaClimatica clima)
        {
            while (distancia > 0)
            {
                double multiplicadorPneu = desgaste.MultiplicadorPneu, distanciaOcorrencia = desgaste.DistanciaDaOcorrencia, multiplicadorClima = clima.MultiplicadorClima;
                int    statusPneu = desgaste.StatusAtualDoPneu, quantidadeDeDesgaste;
                string tipoStatus = desgaste.TipoStatus, climaAtual = clima.Clima;

                //Recalculo da distancia, devido a alteração na autonomia
                if (distanciaMaxima < distancia)
                {
                    distancia = distanciaMaxima;
                }

                if (Math.Round(distancia + Relatorio.KilometrosPercorridos % 100, 10) >= 100)
                {
                    //essa variavel diz quantos kilometros podem ser percorridos até chegar em 100kilometros percorridos.
                    double kilometrosASeremPercorridos = Math.Round(100 - (Relatorio.KilometrosPercorridos % 100), 10);

                    ConsumirCombustivelEPercorrer(Relatorio, kilometrosASeremPercorridos, AutonomiaGasolina, AutonomiaAlcool);

                    if (distancia > 100)
                    {
                        distancia = Math.Round(distancia - Math.Round(100 - (Relatorio.KilometrosPercorridos % 100), 10), 10);
                    }

                    else
                    {
                        distancia = Math.Round(distancia - kilometrosASeremPercorridos, 10);
                    }

                    quantidadeDeDesgaste = DesgasteDoPneu();
                    statusPneu          -= quantidadeDeDesgaste;

                    if (statusPneu == 3)
                    {
                        tipoStatus = "novo";
                    }

                    else if (statusPneu == 2)
                    {
                        tipoStatus = "pouco desgastado";
                    }

                    else
                    {
                        tipoStatus = "desgastado";
                    }


                    distanciaOcorrencia = Relatorio.KilometrosPercorridos;
                    multiplicadorPneu   = CalculaMultiplicadorPneu(statusPneu);
                    Relatorio.StatusPneu.Add(new DesgastePneu(distanciaOcorrencia, multiplicadorPneu, quantidadeDeDesgaste, statusPneu, tipoStatus));
                    desgaste = Relatorio.StatusPneu.ElementAt(Relatorio.StatusPneu.Count - 1);

                    climaAtual         = ViagemCore.GeraClimaRandomico();
                    multiplicadorClima = ViagemCore.CalculaMultiplicadorClima(climaAtual);
                    Relatorio.Clima.Add(new MudancaClimatica(distanciaOcorrencia, multiplicadorClima, climaAtual));
                    clima = Relatorio.Clima.ElementAt(Relatorio.StatusPneu.Count - 1);

                    if (statusPneu == 0)
                    {
                        CalibrarPneu(Relatorio);
                    }
                }
                //DesgastePneu desgaste = Relatorio.StatusPneu.ElementAt(Relatorio.StatusPneu.Count - 1);
                else
                {
                    ConsumirCombustivelEPercorrer(Relatorio, distancia, AutonomiaGasolina, AutonomiaAlcool);
                    distancia = 0.0;
                }

                MensagensComDelay.MensagemDistanciaPercorrida(Relatorio.KilometrosPercorridos);

                AutonomiaGasolina = RetornaAutonomiaGasolina(Relatorio, desgaste.MultiplicadorPneu, clima.MultiplicadorClima);
                AutonomiaAlcool   = RetornaAutonomiaAlcool(Relatorio, desgaste.MultiplicadorPneu, clima.MultiplicadorClima);
                distanciaMaxima   = Math.Round(Math.Round(AutonomiaGasolina * Relatorio.VeiculoNaEstrada.Veiculo.QuantidadeGasolina, 10) + Math.Round(AutonomiaAlcool * Relatorio.VeiculoNaEstrada.Veiculo.QuantidadeAlcool, 10), 10);
            }
        }