private static FuelCar initNewFuelCar(string i_LicensePlateSrting, string i_VehicleModel, float i_EnergyLeft, string i_WheelManufacturer, float i_WheelCurrentAirPressure, string[] i_Parameters) { const bool v_IgnoreCase = true; const FuelEngine.eFuelType k_SupportedCarFuelType = FuelEngine.eFuelType.Octan96; const float k_MaxCarFuelTank = 35; if (i_EnergyLeft > k_MaxCarFuelTank) { throw new ValueOutOfRangeException(k_MaxCarFuelTank); } FuelEngine engine = new FuelEngine(k_MaxCarFuelTank, i_EnergyLeft, null, k_SupportedCarFuelType); if (i_WheelCurrentAirPressure > k_MaxAirPressureInCarWheels) { throw new ValueOutOfRangeException(k_MaxAirPressureInCarWheels); } List <Wheel> wheels = new List <Wheel>(k_NumberOfWheelsInCar); for (int i = 0; i < k_NumberOfWheelsInCar; i++) { wheels.Add(new Wheel(i_WheelManufacturer, i_WheelCurrentAirPressure, k_MaxAirPressureInCarWheels)); } Car.eCarColor color = (Car.eCarColor)Enum.Parse(typeof(Car.eCarColor), i_Parameters[0], v_IgnoreCase); Car.eNumOfDoors numOfDoors = (Car.eNumOfDoors)Enum.Parse(typeof(Car.eNumOfDoors), i_Parameters[1], v_IgnoreCase); return(new FuelCar(i_LicensePlateSrting, i_VehicleModel, wheels, engine, color, numOfDoors)); }
private static FuelMotorcycle initNewFuelMotorcycle(string i_LicensePlateSrting, string i_VehicleModel, float i_EnergyLeft, string i_WheelManufacturer, float i_WheelCurrentAirPressure, string[] i_Parameters) { const bool v_IgnoreCase = true; const float k_MaxAirPressureInFuelMotorcycleWheels = 34; const FuelEngine.eFuelType k_SupportedMotorcycleFuelType = FuelEngine.eFuelType.Octan98; const float k_MaxMotorcycleFuelTank = 8; if (i_EnergyLeft > k_MaxMotorcycleFuelTank) { throw new ValueOutOfRangeException(k_MaxMotorcycleFuelTank); } int engineVolume = int.Parse(i_Parameters[1]); FuelEngine engine = new FuelEngine(k_MaxMotorcycleFuelTank, i_EnergyLeft, engineVolume, k_SupportedMotorcycleFuelType); if (i_WheelCurrentAirPressure > k_MaxAirPressureInFuelMotorcycleWheels) { throw new ValueOutOfRangeException(k_MaxAirPressureInFuelMotorcycleWheels); } List <Wheel> wheels = new List <Wheel>(k_NumberOfWheelsInMotorcycle); for (int i = 0; i < k_NumberOfWheelsInMotorcycle; i++) { wheels.Add(new Wheel(i_WheelManufacturer, i_WheelCurrentAirPressure, k_MaxAirPressureInFuelMotorcycleWheels)); } Motorcycle.eLicenseType licenseType = (Motorcycle.eLicenseType)Enum.Parse(typeof(Motorcycle.eLicenseType), i_Parameters[0], v_IgnoreCase); return(new FuelMotorcycle(i_LicensePlateSrting, i_VehicleModel, wheels, licenseType, engine)); }
private FuelEngine.eFuelType getFuelType() { Console.WriteLine("Please enter fuel type."); printEnumList(new FuelEngine.eFuelType()); FuelEngine.eFuelType fuelType = FuelEngine.CheckFuelType(Console.ReadLine()); return(fuelType); }
internal static void RefuelFuelVehicle(string i_VehicleLicenseNumber, FuelEngine.eFuelType i_TypeOfFuel, float i_AmountToFill) { VehicleInGarage currentVehicle = ListVehiclesInGarage[i_VehicleLicenseNumber]; Vehicle vehicleToAddEnergy = currentVehicle.Vehicle; if (vehicleToAddEnergy.EngineOfVehicle.EngineType != Engine.eEngineType.Fuel) { throw new ArgumentException(string.Format("Invalid input. The type of engine of this vehicle is not Electric{0}", Environment.NewLine)); } FuelEngine fuelEngine = (FuelEngine)vehicleToAddEnergy.EngineOfVehicle; try { fuelEngine.Refuel(i_AmountToFill, i_TypeOfFuel); vehicleToAddEnergy.EngineOfVehicle = fuelEngine; } catch (ArgumentException exception) { throw exception; } catch (OutOfRangeException exception) { throw exception; } }
public void CheckMyChoiceFuelType(FuelEngine.eFuelType i_CurrentFuelType) { bool isInputValid1; bool isInputValid2 = false; FuelEngine.eFuelType myChoise; do { try { myChoise = (FuelEngine.eFuelType) int.Parse(Console.ReadLine()); do { isInputValid1 = true; if (myChoise != i_CurrentFuelType) { Console.WriteLine("Your fuel type is incorrect"); myChoise = (FuelEngine.eFuelType) int.Parse(Console.ReadLine()); i_CurrentFuelType = m_CurrentVehicleInGarage.OwnerVehicle.FuelType; isInputValid1 = false; } }while (!isInputValid1); isInputValid2 = true; } catch { Console.WriteLine("Your fuel type is incorrect"); } }while (!isInputValid2); }
public bool FuelVehicle(string i_PlateNumber, float i_Amount, FuelEngine.eFuelType i_Type) { bool isFueled = false; GarageCustomer customer = FindCustomerByPlateNumber(i_PlateNumber); if (customer != null) { IEngine engine = customer.Vehicle.Engine; if (engine.EngineType() == typeof(FuelEngine)) { FuelEngine fuelEngine = (FuelEngine)engine; if (i_Type.Equals(fuelEngine.FuelType)) { isFueled = fuelEngine.PutGas(i_Amount); } else { throw new ArgumentException("Wrong type of fuel"); } } else { throw new ArgumentException("Trying to put gas in an electric engine"); } } return(isFueled); }
private static FuelEngine.eFuelType getFuelTypeFromUser() { bool isValidFuelType = false; string fuelTypeStringInput; FuelEngine.eFuelType fuelTypeValue = FuelEngine.eFuelType.None; while (!isValidFuelType) { Console.WriteLine("Please enter vehicle's type of fuel"); fuelTypeStringInput = Console.ReadLine(); try { fuelTypeValue = (FuelEngine.eFuelType)Enum.Parse(typeof(FuelEngine.eFuelType), fuelTypeStringInput, true); isValidFuelType = true; } catch (ArgumentException) { Console.WriteLine("Throw on type ful"); Console.WriteLine(string.Format("{0} is not a type of fuel. Try again", fuelTypeStringInput)); } } return(fuelTypeValue); }
public void PumpFuel(string i_LicenceNumber, int i_FuelType, float i_AmountToAdd) { Type vehicleType = m_VehicleCards[i_LicenceNumber].Vehicle.GetType(); MethodInfo pumpFuelMethod = null; foreach (MethodInfo method in vehicleType.GetMethods()) { if (method.Name == k_PumpFuelMethodName) { pumpFuelMethod = method; break; } } if (pumpFuelMethod == null) { throw new ArgumentException(string.Format("The vehicle by {0} licence number does not have a fuel engine", i_LicenceNumber)); } FuelEngine.eFuelType fuelType = (FuelEngine.eFuelType)i_FuelType; if (((FuelEngine)m_VehicleCards[i_LicenceNumber].Vehicle.Engine).FuelType != fuelType) { throw new ArgumentException(string.Format("The vehicle by {0} licence number does not have a fuel type {1}", i_LicenceNumber, fuelType)); } pumpFuelMethod.Invoke(m_VehicleCards[i_LicenceNumber].Vehicle, new object[] { i_AmountToAdd, fuelType }); }
private void fillFuelTank(string i_LicenseNumber, FuelEngine i_FuelEngine) { FuelEngine.eFuelType fuelType = getFuelType(); bool isSuitableFuelType = i_FuelEngine.FuelType == fuelType; if (isSuitableFuelType) { float fuelAddition = getAmountOfEnergyForAddition(Engine.eEngineType.Fuel); float currentFuelInPercentage = i_FuelEngine.CurrentEnergy; float currentFuelLiters = currentFuelInPercentage * i_FuelEngine.MaxEnergyCapacity / 100; bool isValidEnergyAddition = currentFuelLiters + fuelAddition < i_FuelEngine.MaxEnergyCapacity; if (isValidEnergyAddition) { Garage.FillVehicleFuelTank(i_LicenseNumber, fuelType, fuelAddition); printEnergyLoadingMessage(Engine.eEngineType.Fuel, currentFuelInPercentage, i_FuelEngine.CurrentEnergy); } else { Console.WriteLine("The fuel amount you entered is out of range."); } } else { Console.WriteLine("The fuel type is not suitable to the vehicle's engine."); } }
private void FuelUp() { string plateNumber = getPlateNumber(); bool fueled = m_Garage.isCustomerEnrolled(plateNumber); if (fueled) { float fuel = UserCommunicator.getFloatFromUser("How much fuel to put in"); FuelEngine.eFuelType type = UserCommunicator.toFuelType( UserCommunicator.getStringThatEqualsOneOf("Fuel Type", new string[] { "Soler", "Octan95", "Octan96", "Octan98" }, false)); try { fueled = m_Garage.FuelVehicle(plateNumber, fuel, type); } catch (Exception e) { Console.WriteLine("Wrong arguments, vehicles haven't been fueled up."); } } else { printNotEnrolled(); } }
internal Vehicle(string i_LicenseNumber, float i_MaxWheelAirPressure, int i_NumOfWheels, FuelEngine.eFuelType i_FuelType) { m_LicenseNumber = i_LicenseNumber; r_NumOfWheels = i_NumOfWheels; r_MaxWheelAirPressure = i_MaxWheelAirPressure; r_WheelsCollection = new List <Wheel>(); m_FuelType = i_FuelType; }
public void Refuel(string i_LicenseNumber, string i_AmountOfFuelToFill, string i_FuelType) { float amountOfFuelToAdd = ParseUtils.Parse <float>(i_AmountOfFuelToFill, " is not a valid amount of fuel"); FuelEngine.eFuelType fuelType = ParseUtils.EnumParse <FuelEngine.eFuelType>(i_FuelType, " is not a valid type of fuel"); Vehicle vehicle = m_Vehicls[i_LicenseNumber].vehicle; ((FuelEngine)vehicle.EneregyType).FillFuel(amountOfFuelToAdd, fuelType); vehicle.UpadteCurrentPresentOfEneregy(); }
private Car CreateNormalCar(string i_VehicleModel, string i_LicensePlate, string i_WheelManufacturer, float i_CurentAirPreasure, float i_CurrentEnergy) { FuelEngine.eFuelType fuelType = FuelEngine.eFuelType.Octan98; const float k_MaxTankCapacity = 42f; FuelEngine fuelEngine = new FuelEngine(fuelType, k_MaxTankCapacity); fuelEngine.FuelAddition(fuelType, i_CurrentEnergy); Car car = CreateCar(i_VehicleModel, i_LicensePlate, i_WheelManufacturer, fuelEngine, i_CurentAirPreasure); return(car); }
private Motorcycle CreateNormalMotorcycle(string i_VehicleModel, string i_LicensePlate, string i_WheelManufacturer, float i_CurentAirPreasure, float i_CurrentEnergy) { FuelEngine.eFuelType fuelType = FuelEngine.eFuelType.Octan95; const float k_maxTankCapacity = 5.5f; FuelEngine fuelEngine = new FuelEngine(fuelType, k_maxTankCapacity); fuelEngine.FuelAddition(fuelType, i_CurrentEnergy); Motorcycle motorcycle = CreateMotorcycle(i_VehicleModel, i_LicensePlate, i_WheelManufacturer, fuelEngine, i_CurentAirPreasure); return(motorcycle); }
// resposible to validate data and fill up gas public void FillUpGas(string i_LicenseNumber, FuelEngine.eFuelType i_FuelType, float i_AmountToFill) { Customer currentCar = m_Customers[i_LicenseNumber]; if (currentCar.CustomerVehicle.VehicleEngine.TypeOfEngine != "Fuel") { throw new Exception("this Vehicle is an electric Vehicle"); } FuelEngine engineToFill = (FuelEngine)currentCar.CustomerVehicle.VehicleEngine; engineToFill.FillFuel(i_AmountToFill, i_FuelType); }
private static FuelTruck initNewFuelTruck(string i_LicensePlateSrting, string i_VehicleModel, float i_EnergyLeft, string i_WheelManufacturer, float i_WheelCurrentAirPressure, string[] i_Parameters) { const string k_YesString = "Y"; const string k_NoString = "N"; const float k_MaxAirPressureInFuelTruckWheels = 25; const FuelEngine.eFuelType k_SupportedMTruckFuelType = FuelEngine.eFuelType.Soler; const float k_MaxTruckFuelTank = 170; const int k_NumberOfWheels = 16; if (i_EnergyLeft > k_MaxTruckFuelTank) { throw new ValueOutOfRangeException(k_MaxTruckFuelTank); } FuelEngine engine = new FuelEngine(k_MaxTruckFuelTank, i_EnergyLeft, null, k_SupportedMTruckFuelType); if (i_WheelCurrentAirPressure > k_MaxAirPressureInFuelTruckWheels) { throw new ValueOutOfRangeException(k_MaxAirPressureInFuelTruckWheels); } List <Wheel> wheels = new List <Wheel>(k_NumberOfWheels); for (int i = 0; i < k_NumberOfWheels; i++) { wheels.Add(new Wheel(i_WheelManufacturer, i_WheelCurrentAirPressure, k_MaxAirPressureInFuelTruckWheels)); } bool isCarryingDangerousMaterials; string upperCaseParameter = i_Parameters[0].ToUpper(); if (k_YesString == upperCaseParameter) { isCarryingDangerousMaterials = true; } else if (k_NoString == upperCaseParameter) { isCarryingDangerousMaterials = false; } else { throw new FormatException(string.Format("Invalid format. Expected '{0}' or '{1}'", k_YesString, k_NoString)); } float currentCarryingWeight = float.Parse(i_Parameters[1]); return(new FuelTruck(i_LicensePlateSrting, i_VehicleModel, wheels, engine, isCarryingDangerousMaterials, currentCarryingWeight)); }
public void Refuel(string i_LicenseNumber, string i_FuelType, string i_FuelAmountToAdd) { Customer customer = GetCustomer(i_LicenseNumber); if (!(customer.Vehicle.Engine is FuelEngine)) { throw new ArgumentException("Cannot refuel electric engine"); } int optionNumber = int.Parse(i_FuelType); FuelEngine.eFuelType fuelType = (FuelEngine.eFuelType)optionNumber; float amountToAdd = PropertiesValidation.PositiveFloatValidation(i_FuelAmountToAdd); ((FuelEngine)(customer.Vehicle.Engine)).Refuel(amountToAdd, fuelType); }
public void RechargeFuel(string i_VehicleId, FuelEngine.eFuelType i_FuelType, float i_AmountToRecharge) { StoredVehicle vehicleToRecharge = null; FuelEngine engineToRecharge = null; bool isEngineFuel = false; vehicleToRecharge = getStoredVehicle(i_VehicleId); isEngineFuel = vehicleToRecharge.Vehicle.Engine is FuelEngine; if (!isEngineFuel) { throw new ArgumentException("Engine is not FuelEngine."); } engineToRecharge = (vehicleToRecharge.Vehicle.Engine as FuelEngine); engineToRecharge.Recharge(i_AmountToRecharge, i_FuelType); // if not fuel engine, if wrong fuel type, if amount too high. vehicleToRecharge.Vehicle.calculateCurrentEnergyPercent(); }
public void AddFuelToVehicle(string i_License, FuelEngine.eFuelType i_FuelType, float i_AmountToAdd) { try { VehiclesInGarage[i_License].m_Vehicle.m_EnergySource.EnergyToVehicle(i_AmountToAdd, VehiclesInGarage[i_License].m_Vehicle.m_EnergySource); if (IsMax == false) { string msg = string.Format("You successfully Added the fuel CurrentAmountOfEnergy is {0} to vehicle with license No. {1} !", VehiclesInGarage[i_License].m_Vehicle.m_EnergySource.CurrentAmountOfEnergy, i_License); Console.WriteLine(msg); } } catch (KeyNotFoundException ex) { string msg = string.Format( @"The requested license {0} for the status change has not found in the garage system", i_License.ToString()); } }
public bool RefuleVechileWithFuelEngine(string i_LicensePlate, FuelEngine.eFuelType i_RequestedFuelType, float i_AmountOfFuelToFill) { VehicleInGarage requestedVehicle = SearchForVehicleInGarage(i_LicensePlate); bool refuelDone; if (requestedVehicle != null) { bool isFuelEngine = requestedVehicle.TheVehicle.VehicleEngine is FuelEngine; if (isFuelEngine) { FuelEngine vehicleEngine = requestedVehicle.TheVehicle.VehicleEngine as FuelEngine; if (vehicleEngine.TheFuelType == i_RequestedFuelType) { if (requestedVehicle.TheVehicle.VehicleEngine.CurrentAmountOfEnergy + i_AmountOfFuelToFill <= requestedVehicle.TheVehicle.VehicleEngine.MaximumAmountOfEnergy) { requestedVehicle.TheVehicle.VehicleEngine.CurrentAmountOfEnergy += i_AmountOfFuelToFill; requestedVehicle.TheVehicle.VehicleEngine.PercentOfEnergyLeft = (requestedVehicle.TheVehicle.VehicleEngine.CurrentAmountOfEnergy / requestedVehicle.TheVehicle.VehicleEngine.MaximumAmountOfEnergy) * 100; } else { float maxValue = requestedVehicle.TheVehicle.VehicleEngine.MaximumAmountOfEnergy - requestedVehicle.TheVehicle.VehicleEngine.CurrentAmountOfEnergy; throw new ValueOutOfRangeException(0, maxValue); } } else { throw new ArgumentException("Wrong fuel type!"); } } else { throw new ArgumentException("The requested vehicle does not run on gas!"); } refuelDone = true; } else { refuelDone = !true; } return(refuelDone); }
private void fillEnergySource(bool i_FuelRequest) { string requestedCarLicenseNumber = this.getRegularParameterDetails(k_LicenseNumber, ParameterChecker.eExpectedInputType.All); if (this.m_Garage.CheckIfVehicleInGarageByLicenseNumber(requestedCarLicenseNumber)) { const string k_FuelString = "Please enter how much fuel (in liters) you want to add."; const string k_BatteryString = "Please enter how much battery time (in hours) you want to add."; Engine.eEngineType engineType = this.m_Garage.VehiclesDictionary[requestedCarLicenseNumber].Vehicle .Engine.EngineType; bool isFuelEngine = engineType == Engine.eEngineType.FuelEngine; if (isFuelEngine != i_FuelRequest) { throw new ArgumentException($"Wrong request to fill the {engineType}."); } Console.WriteLine(isFuelEngine ? k_FuelString : k_BatteryString); if (float.TryParse(Console.ReadLine(), out float energySourceAmountToAdd)) { if (engineType == Engine.eEngineType.FuelEngine) { FuelEngine.eFuelType fuelType = this.getFuelType(); this.m_Garage.HandleEnergySourceFilling( requestedCarLicenseNumber, energySourceAmountToAdd, fuelType); } else { this.m_Garage.HandleEnergySourceFilling(requestedCarLicenseNumber, energySourceAmountToAdd); } Console.WriteLine( energySourceAmountToAdd + (engineType == Engine.eEngineType.FuelEngine ? " liters were added." : " hours were charged.")); } } else { throw new ArgumentException(k_InvalidLicenseNumberExceptionString); } }
private Truck CreateTruck(string i_VehicleModel, string i_LicensePlate, string i_WheelManufacturer, float i_CurentAirPressure, float i_CurrentEnergy) { FuelEngine.eFuelType fuelTypeForTruck = FuelEngine.eFuelType.Octan96; const float k_MaximumTankCapacity = 135f; Wheel[] wheels = new Wheel[k_NumberOfWheelsForTruck]; for (int i = 0; i < k_NumberOfWheelsForTruck; i++) { wheels[i] = new Wheel(i_WheelManufacturer, k_mMximumAirPressureForTruck); wheels[i].WheelInflation(i_CurentAirPressure); } FuelEngine fuelEngine = new FuelEngine(fuelTypeForTruck, k_MaximumTankCapacity); fuelEngine.FuelAddition(fuelTypeForTruck, i_CurrentEnergy); Truck newTruck = new Truck(i_VehicleModel, i_LicensePlate, wheels, fuelEngine); return(newTruck); }
private static FuelEngine.eFuelType getFuelType() { string fuelTypeRequestMsg = "Please choose fuel type: "; printListOfEnum(fuelTypeRequestMsg, typeof(FuelEngine.eFuelType)); string fuelTypeInput = Console.ReadLine(); while (!checkEnumValidation(typeof(FuelEngine.eFuelType), fuelTypeInput)) { Console.WriteLine("Invalid fuel type option, please try again"); fuelTypeInput = Console.ReadLine(); } FuelEngine.eFuelType fuelType = (FuelEngine.eFuelType)Enum.Parse(typeof(FuelEngine.eFuelType), fuelTypeInput); return(fuelType); }
public void AddFuel(string i_LicenseNumber, float i_FuelToAdd, FuelEngine.eFuelType i_Type) { if (getVehicleInGarage(i_LicenseNumber, out VehicleInGarage currentVehicleInGarage)) { if (currentVehicleInGarage.Vehicle.EnergySource.EnergyType != EnergySource.eEnergyTypes.Fuel) { throw new ArgumentException("wrong operation for this energy source"); } if (!((FuelEngine)currentVehicleInGarage.Vehicle.EnergySource).CheckFuelType(i_Type)) { throw new ArgumentException("not correct fuel type"); } currentVehicleInGarage.Vehicle.EnergySource.FillEnergy(i_FuelToAdd); } currentVehicleInGarage.Vehicle.UpdateRemainingEnergy(); }
public void FillFuelVehicle(string i_LicenseNumber, FuelEngine.eFuelType i_FuelType, float i_AmountToFill) { checkIfVehicleInGarage(i_LicenseNumber); FuelEngine fuelEngine = r_VehiclesInGarage[i_LicenseNumber].Engine as FuelEngine; if (fuelEngine != null) { if (fuelEngine.FuelType != i_FuelType) { throw new ArgumentException("Fuel Type is not a match"); } fuelEngine.FillFuel(i_FuelType, i_AmountToFill); r_VehiclesInGarage[i_LicenseNumber].SetEnergyPercentage(); } else { throw new ArgumentException(string.Format("vehicle {0} is not on fuel!", i_LicenseNumber)); } }
internal void FillFuelVehicle() { while (true) { try { FuelEngine.eFuelType fuelTypeInput = (FuelEngine.eFuelType)InputValidation.EnumChoiseToInt(typeof(FuelEngine.eFuelType), UserConsole.ChooseString("fuel type")); float amountOfFuel = InputValidation.GetFloat("Enter the amount of fuel to fill"); r_Garage.FillFuelVehicle(r_Vehicle.LicenseNumber, fuelTypeInput, amountOfFuel); break; } catch (Exception ex) { UserConsole.ExceptionOutput(ex); if (ex.Message.Contains("not on fuel!")) { break; } } } endAction(); }
public void FillVehicleFuelTank(string i_LicenseNumber, FuelEngine.eFuelType i_FuelType, float i_FuelAddition) { Engine vehicleEngine = AllVehicles[i_LicenseNumber].Vehicle.Engine; bool isFuelEngine = vehicleEngine is FuelEngine; if (isFuelEngine) { bool isSuitableFuelType = i_FuelType == (vehicleEngine as FuelEngine).FuelType; if (isSuitableFuelType) { vehicleEngine.FillEnergy(i_FuelAddition); } else { throw new ArgumentException("The fuel type is not suitable to the vehicle's engine.\n"); } } else { throw new ArgumentException("This vehicle is not powered by a fuel engine.\n"); } }
private static void refuelFuelVehicle() { try { checkValidityOfUserOptionChoice(); } catch (UnavailableOptionException exception) { throw exception; } try { string licenseNumber = getVehicleLicenseNumber(); FuelEngine.eFuelType fuelType = getFuelTypeFromUser(); float amountFuelToFill = getAmountOfEnergyToAdd(); GarageFunctionalityManager.RefuelFuelVehicle(licenseNumber, fuelType, amountFuelToFill); Console.WriteLine("Refule is done."); } catch (Exception exception) { throw exception; } }
public void SetNewProfile( ) { EnergyOfEngine f = new FuelEngine(); EnergyOfEngine e = new ElectricityEngine(); UserTypeOfVehicle(); m_VehicleProfile.NameOfOwner = ArrayOfInfo[0]; m_VehicleProfile.PhoneOfOwner = ArrayOfInfo[1]; if (m_UserVehicleType == GarageEntryOfVehicle.eVehicleType.ElectricyBike || m_UserVehicleType == GarageEntryOfVehicle.eVehicleType.FuelBike) { if (m_UserVehicleType == GarageEntryOfVehicle.eVehicleType.FuelBike) { m_Bike = new Bike(f); m_Bike.m_EnergySource.MaxAmountOfEnergy = m_Bike.MaxFuelCapacity; m_Bike.m_EnergySource.CurrentAmountOfEnergy = float.Parse(ArrayOfInfo[8]); m_FuelType = FuelEngine.eFuelType.Octan96; m_VehicleProfile.m_Vehicle = SetNewVehicles.CreateVehicle(GarageEntryOfVehicle.eVehicleType.FuelBike); m_Bike.EngineType = "fuelEngine"; } else { m_Bike = new Bike(e); m_Bike.m_EnergySource.MaxAmountOfEnergy = m_Bike.MaxBatteryHours; m_Bike.m_EnergySource.CurrentAmountOfEnergy = float.Parse(ArrayOfInfo[8]); m_VehicleProfile.m_Vehicle = SetNewVehicles.CreateVehicle(GarageEntryOfVehicle.eVehicleType.ElectricyBike); m_Bike.EngineType = null; } BikeLicenseType(); m_VehicleProfile.m_Vehicle = m_Bike; m_VehicleProfile.m_Vehicle.WheelsOfVehicle = new Wheel[2]; } if (m_UserVehicleType == GarageEntryOfVehicle.eVehicleType.ElectricyCar || m_UserVehicleType == GarageEntryOfVehicle.eVehicleType.FuelCar) { if (m_UserVehicleType == GarageEntryOfVehicle.eVehicleType.FuelCar) { m_car = new Car(f); m_car.m_EnergySource.MaxAmountOfEnergy = m_car.MaxFuelCapacity; m_car.m_EnergySource.CurrentAmountOfEnergy = float.Parse(ArrayOfInfo[8]); m_FuelType = FuelEngine.eFuelType.Octan98; m_VehicleProfile.m_Vehicle = SetNewVehicles.CreateVehicle(GarageEntryOfVehicle.eVehicleType.FuelCar); m_car.EngineType = "fuelEngine"; } else { m_car = new Car(e); m_car.m_EnergySource.MaxAmountOfEnergy = m_car.MaxBatteryHours; m_car.m_EnergySource.CurrentAmountOfEnergy = float.Parse(ArrayOfInfo[8]); m_VehicleProfile.m_Vehicle = SetNewVehicles.CreateVehicle(GarageEntryOfVehicle.eVehicleType.ElectricyCar); m_car.EngineType = null; } UserColorOfCar(); UserDoorsOfCar(); m_VehicleProfile.m_Vehicle = m_car; m_VehicleProfile.m_Vehicle.WheelsOfVehicle = new Wheel[4]; } if (m_UserVehicleType == GarageEntryOfVehicle.eVehicleType.Truck) { m_VehicleProfile.m_Vehicle = SetNewVehicles.CreateVehicle(GarageEntryOfVehicle.eVehicleType.Truck); m_FuelType = FuelEngine.eFuelType.Soler; m_Truck = new Truck(f); m_Truck.m_EnergySource.MaxAmountOfEnergy = m_Truck.MaxFuelCapacity; m_Truck.m_EnergySource.CurrentAmountOfEnergy = float.Parse(ArrayOfInfo[8]); TruckLoadCapacity(); IsTrunkOfTruckCool(); m_Truck.LoadCapacity = int.Parse(ArrayOfInfo[6]); m_VehicleProfile.m_Vehicle = m_Truck; m_VehicleProfile.m_Vehicle.WheelsOfVehicle = new Wheel[12]; } m_VehicleProfile.m_Vehicle.EnergyInPercentage = float.Parse(ArrayOfInfo[8]); m_VehicleProfile.m_Vehicle.VehicleModel = ArrayOfInfo[2]; m_VehicleProfile.m_Vehicle.LicenseNumber = ArrayOfInfo[3]; m_VehicleProfile.m_Vehicle.SetManufacturerInWheels(ArrayOfInfo[4]); }
public static FuelEngine CreateFuelEngine(FuelEngine.eFuelType i_FuelType, float i_CurrentAmountOfFuel, float i_PercentOfEnergyLeft, float i_MaximumAmountOfEnergy) { FuelEngine fuelEngineForCar = new FuelEngine(i_FuelType, i_CurrentAmountOfFuel, i_PercentOfEnergyLeft, i_MaximumAmountOfEnergy); return(fuelEngineForCar); }