public static float GetCurrentAirPressure(eTypeOfVehicle i_Type, string i_Input)
{
float airPressure = 0;
switch (i_Type)
{
case eTypeOfVehicle.ElectricCar:
airPressure = Vehicle.CheckValidationOfCurrentPressure(i_Input, (float)32, "wrong pressure");
break;
case eTypeOfVehicle.ElectricMotorcycle:
airPressure = Vehicle.CheckValidationOfCurrentPressure(i_Input, (float)30, "wrong pressure");
break;
case eTypeOfVehicle.FuelBasedCar:
airPressure = Vehicle.CheckValidationOfCurrentPressure(i_Input, (float)32, "wrong pressure");
break;
case eTypeOfVehicle.FuelBasedMotorcycle:
airPressure = Vehicle.CheckValidationOfCurrentPressure(i_Input, (float)30, "wrong pressure");
break;
default:
airPressure = Vehicle.CheckValidationOfCurrentPressure(i_Input, (float)28, "wrong pressure");
break;
}
return(airPressure);
}
public static Vehicle CreateVehicle(eTypeOfVehicle i_TypeOfVehicle, string i_LicenseNumber)
{
Vehicle newVehicleToCreate = null;
switch (i_TypeOfVehicle)
{
case eTypeOfVehicle.ElectricCar:
newVehicleToCreate = new ElectricCar(i_LicenseNumber);
break;
case eTypeOfVehicle.ElectricMotorcycle:
newVehicleToCreate = new ElectricMotorcycle(i_LicenseNumber);
break;
case eTypeOfVehicle.FuelTruck:
newVehicleToCreate = new FuelTruck(i_LicenseNumber);
break;
case eTypeOfVehicle.FuelCar:
newVehicleToCreate = new FuelCar(i_LicenseNumber);
break;
case eTypeOfVehicle.FuelMotorcycle:
newVehicleToCreate = new FuelMotorcycle(i_LicenseNumber);
break;
}
return(newVehicleToCreate);
}
public Vehicle InsertNewVehicle(eTypeOfVehicle i_TypeOfVehicle, string i_OwnerPhoneNumber, string i_LicenseNumber, string i_OwnerName, string i_ModelName, string i_WheelManufactorName)
{
Vehicle newVehicle = null;
switch ((eTypeOfVehicle)i_TypeOfVehicle)
{
case eTypeOfVehicle.ElectricCar:
case eTypeOfVehicle.FueldCar:
newVehicle = new Car(i_TypeOfVehicle, i_OwnerPhoneNumber, i_LicenseNumber, i_OwnerName, i_ModelName, i_WheelManufactorName);
break;
case eTypeOfVehicle.ElectricMotorcycle:
case eTypeOfVehicle.FueldMotorcycle:
newVehicle = new Motorcycle(i_TypeOfVehicle, i_OwnerPhoneNumber, i_LicenseNumber, i_OwnerName, i_ModelName, i_WheelManufactorName);
break;
case eTypeOfVehicle.Truck:
newVehicle = new Truck(i_OwnerPhoneNumber, i_LicenseNumber, i_OwnerName, i_ModelName, i_WheelManufactorName);
break;
default:
break;
}
newVehicle.VehicleStatus = eVehicleStatus.InRepair;
m_VehicleList.Add(newVehicle);
return(newVehicle);
}
public Vehicle(eTypeOfVehicle i_TypeOfVehicle, string i_OwnerPhoneNumber, string i_LicenseNumber, string i_OwnerName, string i_ModelName, string i_WheelManufactorName)
{
m_WheelManufactorName = i_WheelManufactorName;
m_TypeOfVehicle = i_TypeOfVehicle;
r_OwnerPhoneNumber = i_OwnerPhoneNumber;
r_LicenseNumber = i_LicenseNumber;
r_OwnerName = i_OwnerName;
r_ModelName = i_ModelName;
}
private void getVehiliceType(out eTypeOfVehicle o_TypeOfVehicle)
{
Console.WriteLine(
@"Please insert vehicle's type:
{0}.Regular motorcycle
{1}.Electric motorcycle
{2}.Regular car
{3}.Electric car
{4}.Truck",
(int)eTypeOfVehicle.RegularMotorcycle,
(int)eTypeOfVehicle.ElectricMotorcycle,
(int)eTypeOfVehicle.RegularCar,
(int)eTypeOfVehicle.ElectricCar,
(int)eTypeOfVehicle.Truck);
o_TypeOfVehicle = (eTypeOfVehicle)GetValidInputs.GetValidInputNumber(1, k_NumTypesOfVehicles);
}
public Motorcycle(eTypeOfVehicle i_TypeOfVehicle, string i_OwnerPhoneNumber, string i_LicenseNumber, string i_OwnerName, string i_ModelName, string i_WheelManufactorName)
: base(i_TypeOfVehicle, i_OwnerPhoneNumber, i_LicenseNumber, i_OwnerName, i_ModelName, i_WheelManufactorName)
{
m_MaxAirPressure = 33f;
AddWheels(k_NumberOfWheels);
if (m_TypeOfVehicle == eTypeOfVehicle.ElectricMotorcycle)
{
m_Engine = new ElectricEngine(1.4f);
}
else if (m_TypeOfVehicle == eTypeOfVehicle.FueldMotorcycle)
{
m_Engine = new FueldEngine(8f, eFuelEngineType.Octane95);
}
m_Properties.Add(m_LicenseType);
m_Properties.Add(m_EngineVolume);
m_PropetiesDetails.Add("The motorcycle license type:");
m_PropetiesDetails.Add("The motorcycle engine type:");
}
public Car(eTypeOfVehicle i_TypeOfVehicle, string i_OwnerPhoneNumber, string i_LicenseNumber, string i_OwnerName, string i_ModelName, string i_WheelManufactorName)
: base(i_TypeOfVehicle, i_OwnerPhoneNumber, i_LicenseNumber, i_OwnerName, i_ModelName, i_WheelManufactorName)
{
AddWheels(k_NumberOfWheels);
m_MaxAirPressure = 31f;
if (m_TypeOfVehicle == eTypeOfVehicle.ElectricCar)
{
m_Engine = new ElectricEngine(1.8f);
}
else if (m_TypeOfVehicle == eTypeOfVehicle.FueldCar)
{
m_Engine = new FueldEngine(8f, eFuelEngineType.Octane95);
}
m_Properties.Add(m_CarColour);
m_Properties.Add(m_CarNumberOfDoors);
m_PropetiesDetails.Add("The car's colour is:");
m_PropetiesDetails.Add("The car's number of doors's are");
}
private eTypeOfVehicle getTypeOfVehichle()
{
Console.Clear();
Console.WriteLine("Choose a type of vehicle: ");
eTypeOfVehicle vehicleType = eTypeOfVehicle.ElectricCar;
int i = 1;
foreach (eTypeOfVehicle type in Enum.GetValues(typeof(eTypeOfVehicle)))
{
Console.WriteLine("({0}) {1}", i, type.ToString());
i++;
}
int getInput = 0;
bool isValidInput = false;
while (!isValidInput)
{
try
{
isValidInput = int.TryParse(Console.ReadLine(), out getInput);
int sizeOfTypes = Enum.GetValues(typeof(eTypeOfVehicle)).Length;
if (getInput <= sizeOfTypes && getInput > 0)
{
isValidInput = true;
}
else
{
isValidInput = false;
Console.WriteLine("Invalid option. Please try again.");
}
}
catch (FormatException e)
{
isValidInput = false;
Console.WriteLine(e.Message);
}
}
vehicleType = (eTypeOfVehicle)getInput;
return(vehicleType);
}
public static Vehicle CreateNewVehicle(eTypeOfVehicle i_TypeOfVehicle, bool i_IsElectricVehicle)
{
Vehicle newVehicle;
if (i_TypeOfVehicle == eTypeOfVehicle.Car)
{
newVehicle = new Car();
}
else if (i_TypeOfVehicle == eTypeOfVehicle.Motorcycle)
{
newVehicle = new Motorcycle();
}
else
{
newVehicle = new Track();
}
newVehicle.SetVehicleEngine(i_IsElectricVehicle);
return(newVehicle);
}
public static Vehicle CreateNewVehicle(eTypeOfVehicle i_TypeOfVehicle)
{
Vehicle m_Vehicle = null;
Fuel fuelSource = null;
ElectricBattery electricSource = null;
switch (i_TypeOfVehicle)
{
case eTypeOfVehicle.ElectricCar:
electricSource = new ElectricBattery(1.8f);
m_Vehicle = new Car(electricSource);
m_Vehicle.SetMaxAirPressureOfWheelInListOfWheels(32);
break;
case eTypeOfVehicle.ElectricMotorcycle:
electricSource = new ElectricBattery(1.9f);
m_Vehicle = new Motorcycle(electricSource);
m_Vehicle.SetMaxAirPressureOfWheelInListOfWheels(29);
break;
case eTypeOfVehicle.FuelCar:
fuelSource = new Fuel(48f);
fuelSource.FuelType = eFuelType.Octan95;
m_Vehicle = new Car(fuelSource);
m_Vehicle.SetMaxAirPressureOfWheelInListOfWheels(32);
break;
case eTypeOfVehicle.FuelMotorcycle:
fuelSource = new Fuel(7.5f);
fuelSource.FuelType = eFuelType.Octan98;
m_Vehicle = new Motorcycle(fuelSource);
m_Vehicle.SetMaxAirPressureOfWheelInListOfWheels(29);
break;
case eTypeOfVehicle.Truck:
fuelSource = new Fuel(190f);
fuelSource.FuelType = eFuelType.Soler;
m_Vehicle = new Truck(fuelSource);
m_Vehicle.SetMaxAirPressureOfWheelInListOfWheels(31);
break;
default:
throw new ArgumentException("Invalid type of vehicle");
}
return m_Vehicle;
}
private void addVehicle()
{
bool isInGarage = false;
string licesnseNumber = this.getCarLicenseNumber(out isInGarage);
if (!isInGarage)
{
string userName = getUserName();
string userPhoneNumber = getUserPhoneNumber();
string modelName = getModelName();
eTypeOfVehicle vehicle = getTypeOfVehichle();
string wheelBrand = getWheelBrand();
Vehicle currVehicle = m_Garage.InsertNewVehicle(vehicle, userPhoneNumber, licesnseNumber, userName, modelName, wheelBrand);
float engineCapacity = getEngineCurrCapacity(currVehicle);
float currAirPressure = getCurrAirPressure(currVehicle);
List <object> properties = getProperties(currVehicle);
m_Garage.InsertAdditionalProperties(currVehicle, engineCapacity, currAirPressure, properties);
}
else
{
m_Garage.FindVehicle(licesnseNumber).VehicleStatus = eVehicleStatus.InRepair;
}
}
public static Vehicle CreateVehicle(eTypeOfVehicle i_TypeOfVehicle, string i_LicenseNumber)
{
switch (i_TypeOfVehicle)
{
case eTypeOfVehicle.ElectricCar:
{
Tire[] electricCarTires = new Tire[4];
for (int i = 0; i < 4; i++)
{
electricCarTires[i] = new Tire(Car.k_MaxPsiInElectricCar);
}
return(new Car(i_LicenseNumber, new BatterySystem(Car.k_MaxBatteryHoursInElectricCar), electricCarTires));
}
case eTypeOfVehicle.ElectricMotorcycle:
{
Tire[] electricMotorocycleTires = new Tire[2];
for (int i = 0; i < 2; i++)
{
electricMotorocycleTires[i] = new Tire(Motorcycle.k_MaxPsiInElectricMotorcycle);
}
return(new Motorcycle(i_LicenseNumber, new BatterySystem(Motorcycle.k_MaxBatteryHoursInElectricMotorcycle), electricMotorocycleTires));
}
case eTypeOfVehicle.RegularCar:
{
Tire[] regularCarTires = new Tire[4];
for (int i = 0; i < 4; i++)
{
regularCarTires[i] = new Tire(Car.k_MaxPsiInFuelCar);
}
return(new Car(i_LicenseNumber, new FuelSystem(Car.k_MaxLitersInFuelCar, eFuelType.Octan96), regularCarTires));
}
case eTypeOfVehicle.RegularMotorcycle:
{
Tire[] RegularMotorcycleTires = new Tire[2];
for (int i = 0; i < 2; i++)
{
RegularMotorcycleTires[i] = new Tire(Motorcycle.k_MaxPsiInRegularMotorcycle);
}
return(new Motorcycle(i_LicenseNumber, new FuelSystem(Motorcycle.k_MaxLitersInFuelMotorcycle, eFuelType.Octan95), RegularMotorcycleTires));
}
default: // eTypeOfVehicle.Truck:
{
Tire[] TruckTires = new Tire[16];
for (int i = 0; i < 16; i++)
{
TruckTires[i] = new Tire(Truck.k_MaxPsiInTruck);
}
return(new Truck(i_LicenseNumber, new FuelSystem(Truck.k_MaxLitersInFuelTruck, eFuelType.Soler), TruckTires));
}
}
}
public bool InsertNewVehicleToGarage(eTypeOfVehicle i_VehicleType, string i_LicenseNumber)
{
bool flag = false;
try
{
m_Vehicle = searchVehicleByLicenseNumber(i_LicenseNumber);
UpdateStatusOfVehicle(m_Vehicle.VehicleLicenseNumber, eVehicleGarageStatus.InRepair);
}
catch (Exception)
{
m_Vehicle = CreateVehicles.CreateNewVehicle(i_VehicleType);
m_Vehicle.VehicleLicenseNumber = i_LicenseNumber;
VehicleCollection.Add(m_Vehicle);
flag = true;
}
return flag;
}
private void setDetailesOfTheNewVehicle(eTypeOfVehicle i_TypeOfVehicle)
{
string vehicleModelName = getModelNameOfVehicle();
string wheelManufacturerName = getManufacturerNameOfWheel();
float wheelCurrentAmountOfAirPressure = getCurrentAmountOfAirPressureOfWheel();
float currentAmountOfEnergy = 0;
float truckWeightCarryingCapacity = 0;
bool truckIsCarryingHazardousMaterials = true;
switch (i_TypeOfVehicle)
{
case eTypeOfVehicle.FuelMotorcycle:
currentAmountOfEnergy = getCurrentAmontOfFuelInLiters();
goto label1;
case eTypeOfVehicle.ElectricMotorcycle:
currentAmountOfEnergy = getBatteryTimeInHours();
label1:
getMotorcycleLicenseType();
int motorcycleEngineCapacity = getEngineCapacityOfMotorcycle();
m_GarageManager.InsertDetailsOfNewMotorcycle(vehicleModelName, wheelManufacturerName, currentAmountOfEnergy, wheelCurrentAmountOfAirPressure, m_LicenseTypeOfMotorcycle, motorcycleEngineCapacity);
break;
case eTypeOfVehicle.FuelCar:
currentAmountOfEnergy = getCurrentAmontOfFuelInLiters();
goto label2;
case eTypeOfVehicle.ElectricCar:
currentAmountOfEnergy = getBatteryTimeInHours();
label2:
getCarColor();
getNumberOfDoors();
m_GarageManager.InsertDetailsOfNewCar(vehicleModelName, wheelManufacturerName, currentAmountOfEnergy, wheelCurrentAmountOfAirPressure, m_ColorOfCar, m_NumberOfDoorsInCar);
break;
case eTypeOfVehicle.Truck:
currentAmountOfEnergy = getCurrentAmontOfFuelInLiters();
truckIsCarryingHazardousMaterials = getIsCarryingHazardousMaterials();
truckWeightCarryingCapacity = getWeightCarryingCapacity();
m_GarageManager.InsertDetailsOfNewTruck(vehicleModelName, wheelManufacturerName, currentAmountOfEnergy, wheelCurrentAmountOfAirPressure, truckWeightCarryingCapacity, truckIsCarryingHazardousMaterials);
break;
}
string vehicleOwnerName = getVehicleOwnerName();
string vehicleOwnerPhone = getVehicleOwnerPhone();
getVehicleGarageStatus();
m_GarageManager.SetVehicleGeneralInformation(vehicleOwnerName, vehicleOwnerPhone, m_VehicleGarageStatus);
}
private void getVehicleType()
{
bool isValidVehicleType = true;
do
{
try
{
m_TypeOfVehicle = (eTypeOfVehicle)parseEnumUserInput(
@"Please enter the vehicle type by choosing a number from the menu:
1. Fuel Motorcycle
2. Electric Motorcycle
3. Fuel Car
4. Electric Car
5. Truck ",
typeof(eTypeOfVehicle));
isValidVehicleType = Enum.IsDefined(typeof(eTypeOfVehicle), m_TypeOfVehicle);
if (!isValidVehicleType)
{
Console.WriteLine("Invalid vehicle type input");
}
}
catch (ArgumentException ex)
{
isValidVehicleType = false;
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
isValidVehicleType = false;
Console.WriteLine(ex.Message);
}
}
while (!isValidVehicleType);
}
protected Vehicle(eTypeOfVehicle i_Type)
{
this.r_Type = i_Type;
}
