public bool FillFuelToMax(Vehicle i_VehicleToActOn, eEngineType i_EngineTypeBasedOnMethodUse, eFuelType i_TypeOfFuelToAdd, float i_AmountOfFuel)
{
bool resultOfFuel = false;
switch (i_EngineTypeBasedOnMethodUse)
{
case eEngineType.Fuel:
FuelEngine currentFuelEngine = m_VehicleInGarage.VehicleEngine as FuelEngine;
resultOfFuel = currentFuelEngine.ChargeEnergyIfPossible(i_AmountOfFuel, i_TypeOfFuelToAdd);
break;
case eEngineType.Electric:
ElectricEngine currentElectricEngine = m_VehicleInGarage.VehicleEngine as ElectricEngine;
resultOfFuel = currentElectricEngine.ChargeEnergyIfPossible(i_AmountOfFuel);
break;
}
if (resultOfFuel)
{
i_VehicleToActOn.PercentOfEnergyLeft = 100;
i_VehicleToActOn.VehicleEngine.CurrentAmountOfEnergy = i_VehicleToActOn.VehicleEngine.MaxAmountOfEnergy;
}
return(resultOfFuel);
}
public static eEngineType GetTypeOfEngine()
{
string vehicleTypeToCheck = Console.ReadLine();
while (true)
{
try
{
eEngineType eTypeOfEngineFromUser = (eEngineType)Enum.Parse(typeof(eEngineType), vehicleTypeToCheck);
if ((int)eTypeOfEngineFromUser > (int)Enum.GetValues(typeof(eEngineType)).Cast <eEngineType>().Last())
{
throw new ValueOutOfRangeException(2, 1);
}
return(eTypeOfEngineFromUser);
}
catch (ArgumentException ex)
{
Console.WriteLine(@"Wrong input due to {0} , please enter electric(1)/fuel(2)", ex.Message);
vehicleTypeToCheck = Console.ReadLine();
}
catch (ValueOutOfRangeException ex)
{
Console.WriteLine(ex.Message);
vehicleTypeToCheck = Console.ReadLine();
}
}
}
public void RefuelVehicl(float i_EnergyAmount, int i_EngineType, string i_LicenseNumber)
{
if (r_AllVehiclesInfo != null && r_AllVehiclesInfo.ContainsKey(i_LicenseNumber))
{
FuelEngine fuelEngine = r_AllVehiclesInfo[i_LicenseNumber].OwenersVehicle.Engine as FuelEngine;
if (fuelEngine != null)
{
eEngineType engineType = (eEngineType)i_EngineType;
if (engineType == fuelEngine.CurrentEngineType)
{
r_AllVehiclesInfo[i_LicenseNumber].OwenersVehicle.Engine.AddEnergy(engineType, i_EnergyAmount);
}
else
{
throw new ArgumentException(string.Format("This vehicle cannot refuel by {0}", engineType.ToString()));
}
}
else
{
throw new ArgumentException("This vehicle does not have a fuel engine");
}
}
else
{
throw new ArgumentException("This vehicle is not in our garage");
}
}
public bool CheckIfVehicleExists(int i_UserCarChoice, int i_UserEngineChoice, string i_LicenseID)
{
eVehicleType vehicleChoice = (eVehicleType)i_UserCarChoice;
eEngineType engineChoice = 0;
engineChoice = (eEngineType)i_UserEngineChoice;
bool isCarExists = false;
if (m_Vehicles != null)
{
foreach (VehicleInTheGarage vehicle in m_Vehicles)
{
if (vehicle.Vehicle.LicenseID == i_LicenseID)
{
if (vehicle.StatusOfVehicle != eStatusVehicle.Repair)
{
vehicle.StatusOfVehicle = eStatusVehicle.Repair;
}
isCarExists = true;
break;
}
}
}
return(isCarExists);
}
public static Engine ParseEngine(eEngineType i_EngineType, float i_FuelAmount)
{
Engine result;
result = i_EngineType == eEngineType.Electric ? ParseElectricEngine() : ParseFuelEngine();
return(result);
}
public static Engine ParseEngine(eEngineType i_EngineType, float i_FuelAmount)
{
Engine result;
result = i_EngineType == eEngineType.Electric ? ParseElectricEngine() : ParseFuelEngine();
return result;
}
internal Engine(eEngineType i_EngineType, float i_EnergyLeft, Vehicle.eVehicleType i_VehicleType)
{
m_EngineType = i_EngineType;
m_CurrentLeftEnergy = i_EnergyLeft;
switch (m_EngineType)
{
case eEngineType.Fuel:
switch (i_VehicleType)
{
case Vehicle.eVehicleType.Car:
m_MaxEnergyCapacity = 45;
m_EnergyType = eEnergyType.Octan98;
break;
case Vehicle.eVehicleType.Motorcycle:
m_MaxEnergyCapacity = 6;
m_EnergyType = eEnergyType.Octan96;
break;
case Vehicle.eVehicleType.Truck:
m_MaxEnergyCapacity = 115;
m_EnergyType = eEnergyType.Octan96;
break;
default:
throw new ArgumentException();
}
break;
case eEngineType.Electric:
switch (i_VehicleType)
{
case Vehicle.eVehicleType.Car:
m_MaxEnergyCapacity = 3.2f;
m_EnergyType = eEnergyType.Electricity;
break;
case Vehicle.eVehicleType.Motorcycle:
m_MaxEnergyCapacity = 1.8f;
m_EnergyType = eEnergyType.Electricity;
break;
default:
throw new ArgumentException();
}
break;
}
if (m_CurrentLeftEnergy > m_MaxEnergyCapacity)
{
throw new ArgumentException();
}
updateEnergyPercentge();
}
public void GetRequiredDetailsForNewVehicle(eVehicleType i_VehicleChoice, eEngineType i_EngineChoice, string i_LicenseID)
{
string modelName = null, wheelManufac = null, vehicleOwner = null, ownerPhone = null;
float energyLeft = 0, currentAirPressure = 0;
m_ConsoleUtils.PrintCurrentAirPressureEnergy(ref currentAirPressure, 0);
m_ConsoleUtils.PrintEnergyLeftQuestion(ref energyLeft, 0);
m_ConsoleUtils.PrintModelNameQuestion(ref modelName);
m_ConsoleUtils.PrintWheelManufacQuestion(ref wheelManufac);
m_ConsoleUtils.PrintVehicleOwnerPhoneQuestion(ref ownerPhone);
m_ConsoleUtils.PrintVehicleOwnerQuestion(ref vehicleOwner);
m_GarageManager.CreateNewVehicleUtils.CreateNewVehicle(m_GarageManager.Vehicles, i_VehicleChoice, i_EngineChoice, i_LicenseID, modelName, wheelManufac, vehicleOwner, ownerPhone, energyLeft, currentAirPressure);
try
{
switch (i_VehicleChoice)
{
case eVehicleType.Bike:
int licenseType = 0, engineVolume = 0;
m_ConsoleUtils.PrintBikeEngineVolumeQuestion(ref engineVolume, 0);
m_ConsoleUtils.PrintLicenseTypeChoicesQuestion(ref licenseType, 0);
m_GarageManager.SetBikeUniqDetails(engineVolume, licenseType);
break;
case eVehicleType.Car:
int carColor = 0, carNumOfDoors = 0;
m_ConsoleUtils.PrintCarColorQuestion(ref carColor, 0);
m_ConsoleUtils.PrintCarNumOfDoorsQuestion(ref carNumOfDoors, 0);
m_GarageManager.SetCarUniqDetails(carColor, carNumOfDoors);
break;
case eVehicleType.Truck:
bool isTruckTrunkCool = false;
float truckTrunkVolume = 0;
m_ConsoleUtils.PrintTruckBoxVolume(ref truckTrunkVolume, 0);
m_ConsoleUtils.PrintTruckTrunkCoolQuestion(ref isTruckTrunkCool, 0);
m_GarageManager.SetTrunkUniqDetails(isTruckTrunkCool, truckTrunkVolume);
break;
default:
break;
}
}
catch (FormatException)
{
m_ConsoleUtils.PrintMessgeNotExistInMenu();
}
}
void InstallEngine(eEngineType i_EngineType, eFuelType?i_FuelType, float i_EngineMaxEnergy)
{
Engine engine;
if (i_EngineType == eEngineType.Fuel)
{
engine = new FuelEngine((eFuelType)i_FuelType);
}
else
{
engine = new ElectricEngine();
}
engine.EnergySourceMaximumAmount = i_EngineMaxEnergy;
m_CreatedVehicle.Engine = engine;
}
public static Vehicle CreateVehicle(eVehicleType i_VehicleType, eEngineType i_EngineType)
{
Vehicle createdVehicle = null;
switch (i_EngineType)
{
case eEngineType.Fuel:
createdVehicle = createFuelVehicle(i_VehicleType);
break;
case eEngineType.Electric:
createdVehicle = createElectricVehicle(i_VehicleType);
break;
}
return(createdVehicle);
}
public static string StringFromType(eEngineType i_EngineType)
{
string result;
switch (i_EngineType)
{
case eEngineType.Electric:
result = "Electric Engine";
break;
case eEngineType.Fuel:
result = "Fuel Engine";
break;
default:
throw new ArgumentException("Unknown engine type");
}
return result;
}
public override void AddEnergy(eEngineType i_FuelType, float i_FuelAmountToAdd)
{
eEngineType checkIfCurentFuelType = (eEngineType)i_FuelType;
if (checkIfCurentFuelType == m_FuelType)
{
if (i_FuelAmountToAdd + CurrenteEnergy <= MaxEnergy)
{
CurrenteEnergy += i_FuelAmountToAdd;
}
else
{
throw new ValueOutOfRangeException(0, MaxEnergy, "Amount of fuel is out of range");
}
}
else
{
throw new ArgumentException("Wrong fuel type");
}
}
public VehiclePreset(
int i_PresetNumber,
string i_PresetDescription,
eVehicleTypes i_VehicleType,
int i_NumberOfWheels,
float i_WheelsMaxPressure,
eEngineType i_EngineType,
eFuelType?i_FuelType,
float i_EngineMaxEnergy
)
{
m_PresetNumber = i_PresetNumber;
m_PresetDescription = i_PresetDescription;
m_VehicleType = i_VehicleType;
m_EngineType = i_EngineType;
m_FuelType = i_FuelType;
m_EngineMaxEnergy = i_EngineMaxEnergy;
m_NumberOfWheels = i_NumberOfWheels;
m_WheelsMaxPressure = i_WheelsMaxPressure;
}
public static string StringFromType(eEngineType i_EngineType)
{
string result;
switch (i_EngineType)
{
case eEngineType.Electric:
result = "Electric Engine";
break;
case eEngineType.Fuel:
result = "Fuel Engine";
break;
default:
throw new ArgumentException("Unknown engine type");
}
return(result);
}
private static Motorcycle CreateMotorCycle(
string i_EngineType, string i_LicenseType, float i_EngineCC, string i_Model, string i_LicenseNumber,
float i_EnergyLevel, string i_Manufacturer, float i_AirPreasure)
{
List <Wheel> wheels = Car.CreateCarWheels(i_Manufacturer, i_AirPreasure);
Engine motorcycleEngine = null;
eEngineType engineTypeParsedToEnum = ParseStringToEngineTypeEnum(i_EngineType);
switch (engineTypeParsedToEnum)
{
case eEngineType.Electric:
motorcycleEngine = CreateElectricEngine(k_MotorCycleBatteryCapacity, i_EnergyLevel);
break;
case eEngineType.Fuel:
motorcycleEngine = CreateFuelEngine(k_MotorCycleFuelCapacity, i_EnergyLevel, eFuelType.Octan95);
break;
}
return(new Motorcycle(ParseStringToLicenseTypeEnum(i_LicenseType), motorcycleEngine, i_EngineCC, i_Model, i_LicenseNumber, wheels));
}
private static Car CreateCar(
string i_EngineType, string i_Color, string i_NumOfDoors,
string i_Model, string i_LicenseNumber, float i_EnergyLevel, string i_WheelManufacturer, float i_AirPreasure)
{
List <Wheel> wheels = Car.CreateCarWheels(i_WheelManufacturer, i_AirPreasure);
Engine carEngine = null;
eEngineType engineTypeParsedToEnum = ParseStringToEngineTypeEnum(i_EngineType);
switch (engineTypeParsedToEnum)
{
case eEngineType.Electric:
carEngine = CreateElectricEngine(k_CarBatteryCapacity, i_EnergyLevel);
break;
case eEngineType.Fuel:
carEngine = CreateFuelEngine(k_CarFuelCapacity, i_EnergyLevel, eFuelType.Octan98);
break;
}
return(new Car(ParseStringToColorTypeEnum(i_Color), carEngine, ParseStringToNumberOfDoorsTypeEnum(i_NumOfDoors), i_Model, i_LicenseNumber, wheels));
}
public override void AddEnergy(eEngineType i_ElectricType, float i_EnergyAmountToAdd)
{
eEngineType checkIfCurentFuelType = (eEngineType)i_ElectricType;
if (checkIfCurentFuelType == m_ElectricType)
{
{
if (i_EnergyAmountToAdd + CurrenteEnergy <= MaxEnergy)
{
CurrenteEnergy += i_EnergyAmountToAdd;
}
else
{
throw new ValueOutOfRangeException(0, MaxEnergy, "Amount of energy is out of range");
}
}
}
else
{
throw new ArgumentException("Not electric type");
}
}
internal ElectricEngine(eEngineType io_ElectricType, float io_MaxAmountOfEnergy)
: base(io_ElectricType, io_MaxAmountOfEnergy)
{
m_ElectricType = io_ElectricType;
}
public Engine(float i_MaxEnergyCapacity, eEngineType i_EngineType)
{
r_MaxEnergyCapacity = i_MaxEnergyCapacity;
r_EngineType = i_EngineType;
}
public Engine(eEngineType i_EngineType, float i__MaxEnergyCapacity)
{
r_EngineType = i_EngineType;
r_MaxEnergyCapacity = i__MaxEnergyCapacity;
}
public Engine(float i_MaxEnergy, float i_EnergyLeft, eEngineType i_EngineType)
{
this.m_EnergyLeft = i_EnergyLeft;
this.m_MaximumEnergy = i_MaxEnergy;
this.m_Enginetype = i_EngineType;
}
public void CreateNewVehicle(List <VehicleInTheGarage> io_VehiclesInGarage, eVehicleType i_VehicleType, eEngineType i_EngineType, string i_LicenseID, string i_ModelName, string i_WheelManufac, string i_OwnerName, string i_OwnerPhoneNumber, float i_EnergyLeft, float i_CurrAirPressure)
{
if (i_EngineType == eEngineType.Gas)
{
switch (i_VehicleType)
{
case eVehicleType.Bike:
io_VehiclesInGarage.Add(new VehicleInTheGarage(new Bike(i_ModelName, i_LicenseID, new GasEngine(k_BikeGasType, k_BikeMaximumAmountOfGas, i_EnergyLeft), i_WheelManufac, i_CurrAirPressure), i_OwnerName, i_OwnerPhoneNumber));
break;
case eVehicleType.Car:
io_VehiclesInGarage.Add(new VehicleInTheGarage(new Car(i_ModelName, new GasEngine(k_CarGasType, k_CarMaximumAmountOfGas, i_EnergyLeft), i_LicenseID, i_WheelManufac, i_CurrAirPressure), i_OwnerName, i_OwnerPhoneNumber));
break;
case eVehicleType.Truck:
io_VehiclesInGarage.Add(new VehicleInTheGarage(new Truck(i_ModelName, new GasEngine(k_TruckGasType, k_TruckMaximumAmountOfGas, i_EnergyLeft), i_LicenseID, i_WheelManufac, i_CurrAirPressure), i_OwnerName, i_OwnerPhoneNumber));
break;
}
}
else
{
switch (i_VehicleType)
{
case eVehicleType.Bike:
io_VehiclesInGarage.Add(new VehicleInTheGarage(new Bike(i_ModelName, i_LicenseID, new ElectricEngine(k_CarMaximumAmountOfElectric, i_EnergyLeft), i_WheelManufac, i_CurrAirPressure), i_OwnerName, i_OwnerPhoneNumber));
break;
case eVehicleType.Car:
io_VehiclesInGarage.Add(new VehicleInTheGarage(new Car(i_ModelName, new ElectricEngine(k_CarMaximumAmountOfElectric, i_EnergyLeft), i_LicenseID, i_WheelManufac, i_CurrAirPressure), i_OwnerName, i_OwnerPhoneNumber));
break;
}
}
}
internal EngineType(eEngineType i_EngineType, float i_MaxEnergy)
{
r_EngineType = i_EngineType;
r_MaxEnergy = i_MaxEnergy;
}
protected Engine(eEngineType i_EngineType, float i_CurrentEnergyQuantity, float i_MaxEnergyQuantity)
{
r_EngineType = i_EngineType;
m_CurrentEnergyQuantity = i_CurrentEnergyQuantity;
r_MaxEnergyQuantity = i_MaxEnergyQuantity;
}
internal Engine(eEngineType i_EngineType)
{
EngineType = i_EngineType;
MaxEnergy = 0;
}
public ElectricEngine(float i_MaxEnergy, float i_EnergyLeft, eEngineType i_EngineType) :
base(i_MaxEnergy, i_EnergyLeft, i_EngineType)
{
}
internal Engine(eEngineType i_EngineType, float i_MaximumEnergySourceCapacity)
{
r_EngineType = i_EngineType;
r_MaximumCapacity = i_MaximumEnergySourceCapacity;
}
internal FuelEngine(eEngineType io_FuelType, float io_MaxAmountOfFuel) : base(io_FuelType, io_MaxAmountOfFuel)
{
m_FuelType = io_FuelType;
}
public virtual void AddEnergy(eEngineType i_Type, float i_EnergyAmountToAdd)
{
}
public FuelEngine(float i_MaxEnergy, float i_EnergyLeft, eEngineType i_EngineType, eFuelType i_FuelType) :
base(i_MaxEnergy, i_EnergyLeft, i_EngineType)
{
this.r_FuelType = i_FuelType;
}
