Example #1
0
        public static Vehicle CreateVehicle(eVehicleType i_VehicleType, string i_ModelName, string i_LicenseNumber)
        {
            Vehicle vehicleToCreate = null;

            switch (i_VehicleType)
            {
            case eVehicleType.FuelCar:
                vehicleToCreate = new FuelCar(i_ModelName, i_LicenseNumber);
                break;

            case eVehicleType.ElectricCar:
                vehicleToCreate = new ElectricCar(i_ModelName, i_LicenseNumber);
                break;

            case eVehicleType.FuelMotorcycle:
                vehicleToCreate = new FuelMotorcycle(i_ModelName, i_LicenseNumber);
                break;

            case eVehicleType.ElectricMotorcycle:
                vehicleToCreate = new ElectricMotorcycle(i_ModelName, i_LicenseNumber);
                break;

            case eVehicleType.FuelTruck:
                vehicleToCreate = new FuelTruck(i_ModelName, i_LicenseNumber);
                break;

            default:
                break;
            }

            return(vehicleToCreate);
        }
Example #2
0
        public static Vehicle Generate(string i_WheelManufacturerName, string i_ModelName, string i_LicensePlate, TypeOfVehicle type)
        {
            Vehicle vehicleToReturn = null;

            switch (type)
            {
            case TypeOfVehicle.CombustionCar:
                vehicleToReturn = new CombustionCar(i_WheelManufacturerName, i_ModelName, i_LicensePlate);
                break;

            case TypeOfVehicle.CombustionMotorcycle:
                vehicleToReturn = new CombustionMotorcycle(i_WheelManufacturerName, i_ModelName, i_LicensePlate);
                break;

            case TypeOfVehicle.ElectricCar:
                vehicleToReturn = new ElectricCar(i_WheelManufacturerName, i_ModelName, i_LicensePlate);
                break;

            case TypeOfVehicle.ElectricMotorcycle:
                vehicleToReturn = new ElectricMotorcycle(i_WheelManufacturerName, i_ModelName, i_LicensePlate);
                break;

            case TypeOfVehicle.Truck:
                vehicleToReturn = new Truck(i_WheelManufacturerName, i_ModelName, i_LicensePlate);
                break;
            }

            return(vehicleToReturn);
        }
Example #3
0
        internal static Dictionary <string, List <string> > GetVehicleProperties(eVehicleType i_VehicleType)
        {
            Vehicle vehicle = null;

            switch (i_VehicleType)
            {
            case eVehicleType.Car:
                vehicle = new FuelCar();
                break;

            case eVehicleType.ElectricCar:
                vehicle = new ElectricCar();
                break;

            case eVehicleType.Motorcycle:
                vehicle = new FuelMotorcycle();
                break;

            case eVehicleType.ElectricMotorcycle:
                vehicle = new ElectricMotorcycle();
                break;

            case eVehicleType.Truck:
                vehicle = new Truck();
                break;
            }

            return(vehicle.GetVehicleProperties());
        }
Example #4
0
        internal static Vehicle CreateVehicle(eVehicleType i_VehicleType, Dictionary <string, string> i_VehicleProperties)
        {
            Vehicle vehicle = null;

            switch (i_VehicleType)
            {
            case eVehicleType.Car:
                vehicle = new FuelCar();
                break;

            case eVehicleType.ElectricCar:
                vehicle = new ElectricCar();
                break;

            case eVehicleType.Motorcycle:
                vehicle = new FuelMotorcycle();
                break;

            case eVehicleType.ElectricMotorcycle:
                vehicle = new ElectricMotorcycle();
                break;

            case eVehicleType.Truck:
                vehicle = new Truck();
                break;
            }

            vehicle.SetVehicleProperties(i_VehicleProperties);

            return(vehicle);
        }
Example #5
0
        public Vehicle GetVehicle(string i_VehicleType, string i_LicenseId, string i_NameOfModel, float i_EnergyPrecent)
        {
            Vehicle vehicle = null;

            if (i_VehicleType.Equals("Fuel Bike"))
            {
                vehicle = new FuelBike(i_LicenseId, i_NameOfModel, i_EnergyPrecent);
            }
            else if (i_VehicleType.Equals("Electric Bike"))
            {
                vehicle = new ElectricBike(i_LicenseId, i_NameOfModel, i_EnergyPrecent);
            }
            else if (i_VehicleType.Equals("Fuel Car"))
            {
                vehicle = new FuelCar(i_LicenseId, i_NameOfModel, i_EnergyPrecent);
            }
            else if (i_VehicleType.Equals("Electric Car"))
            {
                vehicle = new ElectricCar(i_LicenseId, i_NameOfModel, i_EnergyPrecent);
            }
            else if (i_VehicleType.Equals("Truck"))
            {
                vehicle = new Truck(i_LicenseId, i_NameOfModel, i_EnergyPrecent);
            }
            else
            {
                throw new FormatException("The Vheicle type doen't exist");
            }

            return(vehicle);
        }
        public static Vehicle Create(eVehicleTypes i_Identifier, List <object> i_ParamsArray, Wheel[] i_Wheels)
        {
            Vehicle vehicleToReturn = null;

            switch (i_Identifier)
            {
            case eVehicleTypes.FuelCar:
                vehicleToReturn = new FuelCar((string)i_ParamsArray[0], (string)i_ParamsArray[1], (float)i_ParamsArray[2], (eCarColor)i_ParamsArray[3], (eDoorsNumber)i_ParamsArray[4], i_Wheels);
                break;

            case eVehicleTypes.FuelMotorcycle:
                vehicleToReturn = new FuelMotorcycle((string)i_ParamsArray[0], (string)i_ParamsArray[1], (float)i_ParamsArray[2], (eLicenseTypes)i_ParamsArray[3], (int)i_ParamsArray[4], i_Wheels);
                break;

            case eVehicleTypes.ElectricMotorcycle:
                vehicleToReturn = new ElectricMotorcycle((string)i_ParamsArray[0], (string)i_ParamsArray[1], (float)i_ParamsArray[2], (eLicenseTypes)i_ParamsArray[3], (int)i_ParamsArray[4], i_Wheels);
                break;

            case eVehicleTypes.ElectricCar:
                vehicleToReturn = new ElectricCar((string)i_ParamsArray[0], (string)i_ParamsArray[1], (float)i_ParamsArray[2], (eCarColor)i_ParamsArray[3], (eDoorsNumber)i_ParamsArray[4], i_Wheels);
                break;

            case eVehicleTypes.Truck:
                vehicleToReturn = new Truck((string)i_ParamsArray[0], (string)i_ParamsArray[1], (float)i_ParamsArray[2], (bool)i_ParamsArray[3], (int)i_ParamsArray[4], i_Wheels);
                break;

            default:
                break;
            }

            return(vehicleToReturn);
        }
Example #7
0
        public static Vehicle CreateVehicle(Vehicle.eVehicleTypes i_VehicleType, string i_Model, string i_LicenseNumber, float i_EnergyLeft, List <Wheel> i_Wheels, Engine i_engine, Dictionary <string, object> features)
        {
            Vehicle vehicle = null;

            switch (i_VehicleType)
            {
            case Vehicle.eVehicleTypes.ElectricCar:
                vehicle = new ElectricCar((Vehicle.eCarColors)features["i_CarColor"], (Vehicle.eCarDoorsAmount)features["i_CarDoors"]);
                break;

            case Vehicle.eVehicleTypes.GasCar:
                vehicle = new GasCar((Vehicle.eCarColors)features["i_CarColor"], (Vehicle.eCarDoorsAmount)features["i_CarDoors"]);
                break;

            case Vehicle.eVehicleTypes.ElectricMotorcycle:
                vehicle = new ElectricMotorcycle((Vehicle.eLicenseTypes)features["i_MotorcycleLicenseType"], (int)features["i_EngineCapacity"]);
                break;

            case Vehicle.eVehicleTypes.GasMotorcycle:
                vehicle = new GasMotorcycle((Vehicle.eLicenseTypes)features["i_MotorcycleLicenseType"], (int)features["i_EngineCapacity"]);
                break;

            case Vehicle.eVehicleTypes.Truck:
                vehicle = new Truck((bool)features["i_IsCarryingDangerousMaterials"], (float)features["i_MaximumCarryingWeight"]);
                break;
            }

            vehicle.m_EnergyLeft  = i_EnergyLeft;
            vehicle.Engine        = i_engine;
            vehicle.Wheels        = i_Wheels;
            vehicle.LicenseNumber = i_LicenseNumber;
            vehicle.m_Model       = i_Model;
            return(vehicle);
        }
Example #8
0
        public static Vehicle CreateVehicle(string i_ModelName, string i_LicenceNumber, List <string> i_WheelsInfo, float i_EnergyLeftPercent, eVehicleType i_VehicleType, object i_InnerVehicleInfo)
        {
            Vehicle newVehicle = null;

            if (i_VehicleType == eVehicleType.ElectricCar)
            {
                newVehicle = new ElectricCar(i_ModelName, i_LicenceNumber, i_WheelsInfo, i_EnergyLeftPercent, (Car)i_InnerVehicleInfo);
            }
            else if (i_VehicleType == eVehicleType.GasCar)
            {
                newVehicle = new GasCar(i_ModelName, i_LicenceNumber, i_WheelsInfo, i_EnergyLeftPercent, (Car)i_InnerVehicleInfo);
            }
            else if (i_VehicleType == eVehicleType.ElectricMotorcycle)
            {
                newVehicle = new ElectricMotorcycle(i_ModelName, i_LicenceNumber, i_WheelsInfo, i_EnergyLeftPercent, (Motorcycle)i_InnerVehicleInfo);
            }
            else if (i_VehicleType == eVehicleType.GasMotorcycle)
            {
                newVehicle = new GasMotorcycle(i_ModelName, i_LicenceNumber, i_WheelsInfo, i_EnergyLeftPercent, (Motorcycle)i_InnerVehicleInfo);
            }
            else if (i_VehicleType == eVehicleType.GasTruck)
            {
                newVehicle = new GasTruck(i_ModelName, i_LicenceNumber, i_WheelsInfo, i_EnergyLeftPercent, (Truck)i_InnerVehicleInfo);
            }

            return(newVehicle);
        }
Example #9
0
        public Vehicle InitVehicle(eVehicleTypes i_VehicleType)
        {
            Vehicle newVehicle = null;

            switch (i_VehicleType)
            {
            case eVehicleTypes.FUEL_CAR:
                newVehicle = new FuelCar(eFuel.OCTAN_96, r_MaxCarFuelCapability, eWheels.FOUR, r_MaxCarAirPessure);
                break;

            case eVehicleTypes.ELECTRIC_CAR:
                newVehicle = new ElectricCar(r_MaxCarBatteryCapabity, eWheels.FOUR, r_MaxCarAirPessure);
                break;

            case eVehicleTypes.FUEL_MOTORCYCLE:
                newVehicle = new FuelMotorcycle(eFuel.OCTAN_95, r_MaxMotorcycleFuelCapability, eWheels.TWO, r_MaxMotorcycleAirPessure);
                break;

            case eVehicleTypes.ELECTRIC_MOTORCYCLE:
                newVehicle = new ElectricMotorcycle(r_MaxMotorcycleBatteryCapabity, eWheels.TWO, r_MaxMotorcycleAirPessure);
                break;

            case eVehicleTypes.TRUCK:
                newVehicle = new Truck(eFuel.SOLER, r_MaxTruckFuelCapability, eWheels.SIXTEEN, r_MaxTruckAirPessure);
                break;

            default:
                throw new ArgumentException(string.Format("Invalid vehicle type - {0}", i_VehicleType.ToString()));
            }

            return(newVehicle);
        }
        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);
        }
Example #11
0
        public static Vehicle Create(eVehicleType i_VehicleType)
        {
            Vehicle newVehicle = null;

            switch (i_VehicleType)
            {
            case eVehicleType.GasCar:
                newVehicle = new GasCar();
                break;

            case eVehicleType.ElectricCar:
                newVehicle = new ElectricCar();
                break;

            case eVehicleType.GasMotor:
                newVehicle = new GasMotor();
                break;

            case eVehicleType.ElectricMotor:
                newVehicle = new ElectricMotor();
                break;

            case eVehicleType.Truck:
                newVehicle = new Truck();
                break;
            }

            return(newVehicle);
        }
Example #12
0
        public static Vehicle CreateNewVehicle(eVehicleType i_VehicleType, string i_LicenseNumber)
        {
            Vehicle newVehicle;

            switch (i_VehicleType)
            {
            case eVehicleType.FuelCar:
                newVehicle = new FuelCar(i_LicenseNumber);
                break;

            case eVehicleType.ElectricCar:
                newVehicle = new ElectricCar(i_LicenseNumber);
                break;

            case eVehicleType.FuelMotorbike:
                newVehicle = new FuelMotorbike(i_LicenseNumber);
                break;

            case eVehicleType.ElectricMotorbike:
                newVehicle = new ElectricMotorbike(i_LicenseNumber);
                break;

            case eVehicleType.Truck:
                newVehicle = new Truck(i_LicenseNumber);
                break;

            default:
                throw new ArgumentException("Invalid vehicle type");
            }

            return(newVehicle);
        }
Example #13
0
        public Vehicle MakeNewVehicle(eVehicleTypes vehicleType)
        {
            // this method get a vehicle type and return a new vehicle according to the type recieved.
            Vehicle newVehicle = null;

            switch (vehicleType)
            {
            case eVehicleTypes.ElectricCar:
                newVehicle = new ElectricCar();
                break;

            case eVehicleTypes.ElectricMotorbike:
                newVehicle = new ElectricMotorbike();
                break;

            case eVehicleTypes.EnginedCar:
                newVehicle = new EnginedCar();
                break;

            case eVehicleTypes.EnginedMotorbike:
                newVehicle = new EnginedMotorbike();
                break;

            case eVehicleTypes.Truck:
                newVehicle = new Truck();
                break;
            }

            return(newVehicle);
        }
        /**
         * This method creates the wanted vehicle type and returns it
         * Throws ArgumentException if no such vehicle exists
         */
        public static Vehicle MakeVehicle(eVehicleType i_VehicleType)
        {
            Vehicle newVehicle;

            switch (i_VehicleType)
            {
            case eVehicleType.ElectricMotorcycle:
                newVehicle = new ElectricMotorcycle();
                break;

            case eVehicleType.FuelMotorcycle:
                newVehicle = new FuelMotorcycle();
                break;

            case eVehicleType.ElectricCar:
                newVehicle = new ElectricCar();
                break;

            case eVehicleType.FuelCar:
                newVehicle = new FuelCar();
                break;

            case eVehicleType.FuelTruck:
                newVehicle = new FuelTruck();
                break;

            default:
                throw new ArgumentException(string.Format("The index {0} is not supported.", i_VehicleType));
            }

            return(newVehicle);
        }
        public static Vehicle MakeVehicle(Vehicle.eVehicleType i_VehicleType, DetailsOfVehicle i_DetailsOfVehicle)
        {
            Vehicle newVehicle = null;

            switch (i_VehicleType)
            {
            case Vehicle.eVehicleType.FuelCar:
                newVehicle = new FuelCar(i_DetailsOfVehicle as DetailsOfFuelCar);
                break;

            case Vehicle.eVehicleType.ElectricCar:
                newVehicle = new ElectricCar(i_DetailsOfVehicle as DetailsOfElectricCar);
                break;

            case Vehicle.eVehicleType.ElectricMotorcycle:
                newVehicle = new ElectricMotorcycle(i_DetailsOfVehicle as DetailsOfElectricMotorcycle);
                break;

            case Vehicle.eVehicleType.FuelMotorcycle:
                newVehicle = new FuelMotorcycle(i_DetailsOfVehicle as DetailsOfFuelMotorcycle);
                break;

            case Vehicle.eVehicleType.Truck:
                newVehicle = new FuelTruck(i_DetailsOfVehicle as DetailsOfFuelTruck);
                break;
            }

            return(newVehicle);
        }
Example #16
0
        public static Vehicle GenerateNewVehicle(eVehicleToGenerate i_VehicleToGenerate, List <string> i_NewVehicleData)
        {
            Vehicle newVehicle = null;

            Motorcycle.eMotorcycleLicenseType motorcycleLicenseType = 0;
            Car.eCarColorOptions carColor         = 0;
            Car.eNumberOfDoors   carNumberOfDoors = 0;

            if (i_VehicleToGenerate == eVehicleToGenerate.ElectricCar || i_VehicleToGenerate == eVehicleToGenerate.GasCar)
            {
                carColor         = (Car.eCarColorOptions)System.Enum.Parse(typeof(GasCar.eCarColorOptions), i_NewVehicleData[k_PlaceHolderForCarColor]);
                carNumberOfDoors = (Car.eNumberOfDoors)System.Enum.Parse(typeof(Car.eNumberOfDoors), i_NewVehicleData[k_PlaceHolderForCarDoorsNumber]);
            }

            if (i_VehicleToGenerate == eVehicleToGenerate.ElectricMotorcycle || i_VehicleToGenerate == eVehicleToGenerate.GasMotorcycle)
            {
                motorcycleLicenseType = (Motorcycle.eMotorcycleLicenseType)System.Enum.Parse(typeof(Motorcycle.eMotorcycleLicenseType), i_NewVehicleData[k_PlaceHolderForMotorcycleLicenseType]);
            }

            switch (i_VehicleToGenerate)
            {
            case eVehicleToGenerate.GasTruck:
                Truck.eTruckCargo containsDangerousCargo = (Truck.eTruckCargo)System.Enum.Parse(typeof(Truck.eTruckCargo), i_NewVehicleData[k_PlaceHolderForTruckContainsDangerousCargo]);
                newVehicle = new GasTruck(k_GasTruckMaxFuelTankCapacity, containsDangerousCargo, k_GasTruckFuelType, float.Parse(i_NewVehicleData[k_PlaceHolderForTruckVolumeCapacity]),
                                          float.Parse(i_NewVehicleData[k_PlaceHolderForTruckMaxAllowedCargoWeight]), i_NewVehicleData[k_PlaceHolderForVehicleNumber], i_NewVehicleData[k_PlaceHolderForVehicleModel],
                                          k_TruckNumberOfWheels, i_NewVehicleData[k_PlaceHolderForWheelManufacturer], k_TruckMaxAirPressure);
                break;

            case eVehicleToGenerate.GasMotorcycle:
                newVehicle = new GasMotorcycle(k_GasMotorcycleMaxFuelTankCapacity, k_GasMotorcycleFuelType, motorcycleLicenseType,
                                               int.Parse(i_NewVehicleData[k_PlaceHolderForMotorcycleEngineCapacity]), i_NewVehicleData[k_PlaceHolderForVehicleNumber],
                                               i_NewVehicleData[k_PlaceHolderForVehicleModel], k_MotorcycleNumberOfWheels, i_NewVehicleData[k_PlaceHolderForWheelManufacturer],
                                               k_MotorcycleMaxAirPressure);
                break;

            case eVehicleToGenerate.ElectricMotorcycle:
                newVehicle = new ElectricMotorcycle(k_ElectricMotorcycleMaxBatteryTimeInHours, motorcycleLicenseType, int.Parse(i_NewVehicleData[k_PlaceHolderForMotorcycleEngineCapacity]),
                                                    i_NewVehicleData[k_PlaceHolderForVehicleNumber], i_NewVehicleData[k_PlaceHolderForVehicleModel], k_MotorcycleNumberOfWheels, i_NewVehicleData[k_PlaceHolderForWheelManufacturer],
                                                    k_MotorcycleMaxAirPressure);
                break;

            case eVehicleToGenerate.GasCar:
                newVehicle = new GasCar(k_GasCarMaxFuelTankCapacity, k_GasCarFuelType, carColor, carNumberOfDoors, i_NewVehicleData[k_PlaceHolderForVehicleNumber],
                                        i_NewVehicleData[k_PlaceHolderForVehicleModel], k_CarNumberOfWheels,
                                        i_NewVehicleData[k_PlaceHolderForWheelManufacturer], k_CarMaxAirPressure);
                break;

            case eVehicleToGenerate.ElectricCar:
                newVehicle = new ElectricCar(k_ElectricCarMaxBatteryTimeInHours, carColor, carNumberOfDoors, i_NewVehicleData[k_PlaceHolderForVehicleNumber],
                                             i_NewVehicleData[k_PlaceHolderForVehicleModel], k_CarNumberOfWheels,
                                             i_NewVehicleData[k_PlaceHolderForWheelManufacturer], k_CarMaxAirPressure);
                break;

            default:
                break;
            }

            return(newVehicle);
        }
Example #17
0
        public static ElectricCar CreateElectricCar(string i_VehicleModel, string i_LicencePlate, float i_BatteryLeft, eCarColors i_Color, eNumOfDoors i_NumOfDoors,
                                                    string i_WheelMaker, float i_WheelCurrentPressure, VehicleOwner i_Owner)
        {
            ElectricCar electricCar = new ElectricCar(i_VehicleModel, i_LicencePlate, i_BatteryLeft, k_CarMaxBattery, i_Color, k_CarNumOfWheels, i_NumOfDoors, i_Owner);

            GenerateWheels(electricCar, k_CarMaxWheelPressure, i_WheelMaker, i_WheelCurrentPressure);

            return(electricCar);
        }
Example #18
0
        public static Vehicle createVehicleFromType(eVehicleType i_VehicletoCreate, string i_ModelName, string i_LicenceID, object i_UniqueParameter1, object i_UniqueParameter2, string i_WheelsManfacturer, float i_AmountOfCurrentEnergyLeft)
        {
            Vehicle newVehicle = new Vehicle(i_ModelName, i_LicenceID);

            if ((i_VehicletoCreate == eVehicleType.FuelMotorBike) || (i_VehicletoCreate == eVehicleType.ElectricMotorBike))
            {
                eLicenceType licenceID      = (eLicenceType)i_UniqueParameter1;
                int          engineCapacity = (int)i_UniqueParameter2;
                if (i_VehicletoCreate == eVehicleType.FuelMotorBike)
                {
                    FuelMotorBike newFuelMotorBike = new FuelMotorBike(i_ModelName, i_LicenceID, licenceID, engineCapacity, i_WheelsManfacturer, i_AmountOfCurrentEnergyLeft);
                    newVehicle = newFuelMotorBike;
                    newVehicle = newVehicle as FuelMotorBike;
                }
                else
                {
                    ElectricMotorBike newElectricMotorBike = new ElectricMotorBike(i_ModelName, i_LicenceID, licenceID, engineCapacity, i_WheelsManfacturer, i_AmountOfCurrentEnergyLeft);
                    newVehicle = newElectricMotorBike;
                    newVehicle = newVehicle as ElectricMotorBike;
                }
            }
            else if ((i_VehicletoCreate == eVehicleType.FuelCar) || (i_VehicletoCreate == eVehicleType.ElectricCar))
            {
                eCarColor    carColor    = (eCarColor)i_UniqueParameter1;
                eDoorsAmount doorsAmount = (eDoorsAmount)i_UniqueParameter2;
                if (i_VehicletoCreate == eVehicleType.FuelCar)
                {
                    FuelCar newFuelCar = new FuelCar(i_ModelName, i_LicenceID, carColor, doorsAmount, i_WheelsManfacturer, i_AmountOfCurrentEnergyLeft);
                    newVehicle = newFuelCar;
                    newVehicle = newVehicle as FuelCar;
                }
                else
                {
                    ElectricCar newElectricCar = new ElectricCar(i_ModelName, i_LicenceID, carColor, doorsAmount, i_WheelsManfacturer, i_AmountOfCurrentEnergyLeft);
                    newVehicle = newElectricCar;
                    newVehicle = newVehicle as ElectricCar;
                }
            }
            else if (i_VehicletoCreate == eVehicleType.Truck)
            {
                bool  carryingToxic = (bool)i_UniqueParameter1;
                float loadVolume    = (float)i_UniqueParameter2;
                Truck newTruck      = new Truck(i_ModelName, i_LicenceID, carryingToxic, loadVolume, i_WheelsManfacturer, i_AmountOfCurrentEnergyLeft);
                newVehicle = newTruck;
                newVehicle = newVehicle as Truck;
            }
            else
            {
                throw new ArgumentException();
            }
            if (newVehicle == null)
            {
                throw new FormatException();
            }
            return(newVehicle);
        }
 public CreateVehicle(Vehicle i_Vehicle)
 {
     vehicle            = i_Vehicle;
     normalCar          = new NormalCar(vehicle);
     electricCar        = new ElectricCar(vehicle);
     normalMotorcycle   = new NormalMotorcycle(vehicle);
     electricMotorcycle = new ElectricMotorcycle(vehicle);
     truck = new Truck(vehicle);
     GetDataFromUser();
 }
Example #20
0
        public static Vehicles CreatElectricCar(int i_AmountOfDoors, float i_BatteryTimeremainingInhours, Car.eColor i_ColorOfCar
                                                , string i_ModelName, string i_LicenseNumber,
                                                float i_PercentageOfEnergyRemainingInItsEnergysource, float i_CurrentAirPressur, String i_WheelManufacturerName)
        {
            ElectricCar NewElectricCar = new ElectricCar(i_AmountOfDoors, i_BatteryTimeremainingInhours, i_ColorOfCar
                                                         , i_ModelName, i_LicenseNumber,
                                                         i_PercentageOfEnergyRemainingInItsEnergysource, i_CurrentAirPressur, i_WheelManufacturerName);

            return(NewElectricCar);
        }
        private bool handleBatteryTimeSpan(string i_Answer, Vehicle i_VehicleInSetting)
        {
            bool succeed = true;

            ElectricCar        electricVehicle    = i_VehicleInSetting as ElectricCar;
            ElectricMotorcycle electricMotorcycle = i_VehicleInSetting as ElectricMotorcycle;

            if (electricVehicle != null)
            {
                succeed = float.TryParse(i_Answer, out float batteryCapacity);

                if (succeed)
                {
                    try
                    {
                        electricVehicle.MaximalBatteryTime = batteryCapacity;
                        electricVehicle.BatteryTimeLeft    = batteryCapacity / 2;
                    }
                    catch
                    {
                        succeed = false;
                    }
                }
                else
                {
                    succeed = false;
                }
            }

            if (electricMotorcycle != null)
            {
                succeed = float.TryParse(i_Answer, out float batteryCapacity);

                if (succeed)
                {
                    try
                    {
                        electricMotorcycle.MaximalBatteryTime = batteryCapacity;
                        electricMotorcycle.BatteryTimeLeft    = batteryCapacity / 2;
                    }
                    catch
                    {
                        succeed = false;
                    }
                }
                else
                {
                    succeed = false;
                }
            }

            return(succeed);
        }
Example #22
0
        public static Vehicle CreateElectricCar(Vehicle.BasicInformationOfVehicleAndOwner informationOfVehicleAndOwner, Car.e_Color i_color, Car.e_NumberOfDoors i_numberOfDoors)
        {
            Vehicle electricCar = new ElectricCar(
                informationOfVehicleAndOwner.m_ModelName,
                informationOfVehicleAndOwner.m_LicenseNumber,
                informationOfVehicleAndOwner.m_WheelManufacturer,
                informationOfVehicleAndOwner.m_CurrentAirPressure,
                informationOfVehicleAndOwner.m_AmountEnergyResource,
                i_color,
                i_numberOfDoors);

            return(electricCar);
        }
Example #23
0
        public static Vehicle MakeNewVehicle(eVehicle i_TypeToCreate, string i_ModelName, string i_LicensePlateNumber, out List <string> o_QuestionsToAsk, out List <string> o_Attributes)
        {
            switch (i_TypeToCreate)
            {
            case eVehicle.ElectricCar:
            {
                o_QuestionsToAsk = ElectricCar.GetQuestions();
                o_Attributes     = ElectricCar.GetAtributes();
                return(new ElectricCar(i_ModelName, i_LicensePlateNumber, 4, 32, 2.1f));
            }

            case eVehicle.FuelCar:
            {
                o_QuestionsToAsk = FuelCar.GetQuestions();
                o_Attributes     = FuelCar.GetAtributes();
                return(new FuelCar(i_ModelName, i_LicensePlateNumber, 4, 32, FuelVehicle.eFuel.Octan96, 60));
            }

            case eVehicle.ElectricMotorcycle:
            {
                o_QuestionsToAsk = ElectricMotorcycle.GetQuestions();
                o_Attributes     = ElectricMotorcycle.GetAtributes();
                return(new ElectricMotorcycle(i_ModelName, i_LicensePlateNumber, 2, 30, 1.2f));
            }

            case eVehicle.FuelMotorcycle:
            {
                o_QuestionsToAsk = FuelMotorcycle.GetQuestions();
                o_Attributes     = FuelMotorcycle.GetAtributes();

                return(new FuelMotorcycle(i_ModelName, i_LicensePlateNumber, 2, 30, FuelVehicle.eFuel.Octan95, 7));
            }

            case eVehicle.Truck:
            {
                o_QuestionsToAsk = Truck.GetQuestions();
                o_Attributes     = Truck.GetAtributes();
                return(new Truck(i_ModelName, i_LicensePlateNumber, 16, 28, FuelVehicle.eFuel.Soler, 120));
            }

            default:
            {
                o_QuestionsToAsk = null;
                o_Attributes     = null;
                return(null);
            }
            }
        }
        public static Vehicle MakeVehicle(eVehicleType i_VehicleType, List <object> i_Values)
        {
            Vehicle vehicle = null;

            switch (i_VehicleType)
            {
            case eVehicleType.ElectricBike:
            {
                vehicle = new ElectricBike(i_Values[0].ToString(), i_Values[1].ToString(), i_Values[4].ToString(),
                                           (float)i_Values[5], (eLicenseType)i_Values[6], (int)i_Values[7]);
                break;
            }

            case eVehicleType.FuelBike:
            {
                vehicle = new FuelBike(i_Values[0].ToString(), i_Values[1].ToString(), i_Values[4].ToString(),
                                       (float)i_Values[5], (eLicenseType)i_Values[6], (int)i_Values[7]);
                break;
            }

            case eVehicleType.ElectricCar:
            {
                vehicle = new ElectricCar(i_Values[0].ToString(), i_Values[1].ToString(), i_Values[4].ToString(),
                                          (float)i_Values[5], (eCarColor)i_Values[6], (eNumOfDoors)i_Values[7]);
                break;
            }

            case eVehicleType.FuelCar:
            {
                vehicle = new FuelCar(i_Values[0].ToString(), i_Values[1].ToString(), i_Values[4].ToString(),
                                      (float)i_Values[5], (eCarColor)i_Values[6], (eNumOfDoors)i_Values[7]);
                break;
            }

            case eVehicleType.Truck:
            {
                vehicle = new Truck(i_Values[0].ToString(), i_Values[1].ToString(), i_Values[4].ToString(),
                                    (float)i_Values[5], (bool)i_Values[6], (float)i_Values[7]);
                break;
            }
            }

            return(vehicle);
        }
Example #25
0
        public static Vehicle CreateVehicle(Utilities.eTypeOfVehicle i_VehicleType, string i_ModelName, string i_NumberOfCarLicense, string i_NameOfManufacturer, float i_CurTirePressure)
        {
            Vehicle createdVehicle = null;

            switch (i_VehicleType)
            {
            case Utilities.eTypeOfVehicle.ElectricCar:
            {
                createdVehicle = new ElectricCar(i_ModelName, i_NumberOfCarLicense, i_NameOfManufacturer, i_CurTirePressure);
                break;
            }

            case Utilities.eTypeOfVehicle.ElectricMotorcycle:
            {
                createdVehicle = new ElectricMotorcycle(i_ModelName, i_NumberOfCarLicense, i_NameOfManufacturer, i_CurTirePressure);
                break;
            }

            case Utilities.eTypeOfVehicle.FuelBasedCar:
            {
                createdVehicle = new FuelBasedCar(i_ModelName, i_NumberOfCarLicense, i_NameOfManufacturer, i_CurTirePressure);
                break;
            }

            case Utilities.eTypeOfVehicle.FuelBasedMotorcycle:
            {
                createdVehicle = new FuelBasedMotorcycle(i_ModelName, i_NumberOfCarLicense, i_NameOfManufacturer, i_CurTirePressure);
                break;
            }

            case Utilities.eTypeOfVehicle.FuelBasedTruck:
            {
                createdVehicle = new FuelBasedTruck(i_ModelName, i_NumberOfCarLicense, i_NameOfManufacturer, i_CurTirePressure);
                break;
            }

            default:
            {
                throw new ArgumentException("Please enter a valid vehicle");
            }
            }

            return(createdVehicle);
        }
Example #26
0
        // check if the garage can handle with that king of vehicle
        private bool checkValidVehicle(Vehicle i_Vehicle)
        {
            bool               validFuelCar = false, validElectronicCar = false, validFuelMotor = false, validElectronicMotor = false, validTruck = false;
            FuelBaseCar        fuelBaseCar          = i_Vehicle as FuelBaseCar;
            ElectricCar        electronicCar        = i_Vehicle as ElectricCar;
            FuelBaseMotorcycle fuelBaseMotorcycle   = i_Vehicle as FuelBaseMotorcycle;
            ElectricMotorcycle electronicMotorcycle = i_Vehicle as ElectricMotorcycle;
            Truck              truck = i_Vehicle as Truck;

            if (fuelBaseCar != null)
            {
                validFuelCar = checkFuelBaseVehicleValid(
                    fuelBaseCar, r_FuelTypeGarageSupportForCarList, r_MaxFuelTankGarageSupportForFuelCarList,
                    r_NumOfWheelsGarageSupportForCarList, r_MaxAirPressureGarageSupportForCarList);
            }
            else if (electronicCar != null)
            {
                validElectronicCar = checkElectronicVehicleValid(
                    electronicCar, r_MaxBatteryTimeGarageSupportForElectricCarList,
                    r_NumOfWheelsGarageSupportForCarList, r_MaxAirPressureGarageSupportForCarList);
            }
            else if (fuelBaseMotorcycle != null)
            {
                validFuelMotor = checkFuelBaseVehicleValid(
                    fuelBaseMotorcycle, r_FuelTypeGarageSupportForMotorList, r_MaxFuelTankGarageSupportForFuelMotorList,
                    r_NumOfWheelsGarageSupportForMotorList, r_MaxAirPressureGarageSupportForMotorList);
            }
            else if (electronicMotorcycle != null)
            {
                validElectronicMotor = checkElectronicVehicleValid(
                    electronicMotorcycle, r_MaxBatteryTimeGarageSupportForElectricMotorList,
                    r_NumOfWheelsGarageSupportForMotorList, r_MaxAirPressureGarageSupportForMotorList);
            }
            else if (truck != null)
            {
                validTruck = checkFuelBaseVehicleValid(
                    truck, r_FuelTypeGarageSupportForTruckList, r_MaxFuelTankGarageSupportForTruckList,
                    r_NumOfWheelsGarageSupportForTruckList, r_MaxAirPressureGarageSupportForTruckList);
            }

            return(validFuelCar || validElectronicCar || validFuelMotor || validElectronicMotor || validTruck);
        }
Example #27
0
        public static Vehicle CreateKindOfVehicle(eKindOfVehicle i_KindOfVehicle, List <QuestionAnswer> i_InitialMessages)
        {
            const int k_UserName      = 0;
            const int k_UserPhone     = 1;
            const int k_LicenseNumber = 2;
            Vehicle   vehicle         = null;

            switch (i_KindOfVehicle)
            {
            case eKindOfVehicle.ElectricCar:
            {
                vehicle = new ElectricCar(i_InitialMessages[k_UserName].Answer, i_InitialMessages[k_UserPhone].Answer, i_InitialMessages[k_LicenseNumber].Answer);
                break;
            }

            case eKindOfVehicle.ElectricMotorcycle:
            {
                vehicle = new ElectricMotorcycle(i_InitialMessages[k_UserName].Answer, i_InitialMessages[k_UserPhone].Answer, i_InitialMessages[k_LicenseNumber].Answer);
                break;
            }

            case eKindOfVehicle.GasCar:
            {
                vehicle = new GasCar(i_InitialMessages[k_UserName].Answer, i_InitialMessages[k_UserPhone].Answer, i_InitialMessages[k_LicenseNumber].Answer);
                break;
            }

            case eKindOfVehicle.GasMotorcycle:
            {
                vehicle = new GasMotorcycle(i_InitialMessages[k_UserName].Answer, i_InitialMessages[k_UserPhone].Answer, i_InitialMessages[k_LicenseNumber].Answer);
                break;
            }

            case eKindOfVehicle.Truck:
            {
                vehicle = new Truck(i_InitialMessages[k_UserName].Answer, i_InitialMessages[k_UserPhone].Answer, i_InitialMessages[k_LicenseNumber].Answer);
                break;
            }
            }

            return(vehicle);
        }
Example #28
0
        public static Vehicle CreateNewElectricCar(
            string i_ModelName,
            string i_LicenseNumber,
            string[] i_ManufacturerNamesOfAllTires,
            float[] i_CurrentPressureOfAllTires,
            float i_RemainingBatteryTime,
            Car.eDoorCount i_DoorsAmount,
            Car.eColor i_Color)
        {
            Vehicle vehicle = new ElectricCar(
                i_ModelName,
                i_LicenseNumber,
                i_ManufacturerNamesOfAllTires,
                i_CurrentPressureOfAllTires,
                i_RemainingBatteryTime,
                i_DoorsAmount,
                i_Color);

            return(vehicle);
        }
Example #29
0
        public void SetCarAdditionalParams(string i_LicenseNumber, int i_VehicleColor, int i_NumOfDoors)
        {
            GarageVehicle garageVehicle = VehiclesInGarage[i_LicenseNumber];

            eColors color      = checkIfValidColorParam(i_VehicleColor);
            eDoors  numOfDoors = checkIfValidDoorsParam(i_NumOfDoors);

            if (garageVehicle.Vehicle is FuelCar)
            {
                FuelCar fuelCar = garageVehicle.Vehicle as FuelCar;
                fuelCar.CarDetails.VehicleColor = color;
                fuelCar.CarDetails.NumOfDoors   = numOfDoors;
            }
            else if (garageVehicle.Vehicle is ElectricCar)
            {
                ElectricCar electricCar = garageVehicle.Vehicle as ElectricCar;
                electricCar.CarDetails.VehicleColor = color;
                electricCar.CarDetails.NumOfDoors   = numOfDoors;
            }
        }
        private bool handleCarDoorNumber(string i_Answer, Vehicle i_VehicleInSetting)
        {
            bool succeed = byte.TryParse(i_Answer, out byte doorNumberInByte);

            ElectricCar electricCar = i_VehicleInSetting as ElectricCar;
            FuelBaseCar fuelCar     = i_VehicleInSetting as FuelBaseCar;

            eDoorsNumber doorNumber = ElectricCar.CovertNumToDoorNumber(doorNumberInByte);

            if (succeed && fuelCar != null)
            {
                try
                {
                    fuelCar.DoorsNumber = doorNumber;
                    succeed             = true;
                }
                catch
                {
                    succeed = false;
                }
            }
            else if (succeed && electricCar != null)
            {
                try
                {
                    electricCar.DoorsNumber = doorNumber;
                    succeed = true;
                }
                catch
                {
                    succeed = false;
                }
            }
            else
            {
                succeed = false;
            }

            return(succeed);
        }