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);
}
