public string FindBestVehicleFor(Track track, bool considerReload = true, bool considerRange = true)
{
Dictionary <string, float> candidates = new Dictionary <string, float>();
string trackTypeName = track.vehicleTypeName;
Vehicle.VehicleType trackVehicleType = Vehicle.sVehicleTypes[trackTypeName];
foreach (Launcher launcher in launchers)
{
foreach (string vehicle in launcher.vehicleNames)
{
if (launcher.vehicleCounts[launcher.vehicleNames.IndexOf(vehicle)] <= 0 || (launcher.isLoaded == false && considerReload))
{
continue;
}
if (launcher.enabled == false)
{
continue;
}
if (Vehicle.sVehicleCanEngage.ContainsKey(vehicle) == false)
{
Debug.LogError("Error: No Engage List for " + vehicle);
}
bool canEngage = Vehicle.sVehicleCanEngage[vehicle][(int)trackVehicleType];
bool canBeEngaged = Vehicle.sVehicleCanBeEngaged[track.vehicleTypeName][(int)Vehicle.sVehicleTypes[vehicle]];
if (canEngage && canBeEngaged)
{
float eta = Vector3.Distance(self.position, track.predictedPositionAtTime(0)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
float range = Vector3.Distance(self.position, track.predictedPositionAtTime(eta));
if (range <= Vehicle.sVehicleRanges[vehicle] || considerReload == false)
{
if (candidates.ContainsKey(vehicle) == false)
{
candidates.Add(vehicle, Vehicle.sVehicleRanges[vehicle]);
}
}
}
}
}
if (candidates.Count == 0)
{
return("");
}
else
{
float minRange = candidates.Min <KeyValuePair <string, float> >((KeyValuePair <string, float> kv) => { return(kv.Value); });
string result = candidates.First((KeyValuePair <string, float> kv2) => { return(kv2.Value == minRange); }).Key;
return(result);
}
}
public static int GetPrice(Vehicle.VehicleType type)
{
if (type == Vehicle.VehicleType.Car)
{
return(35000);
}
else if (type == Vehicle.VehicleType.Motorcycle)
{
return(15000);
}
else if (type == Vehicle.VehicleType.MotorHome)
{
return(90000);
}
else if (type == Vehicle.VehicleType.SportsCar)
{
return(80000);
}
else if (type == Vehicle.VehicleType.Truck)
{
return(60000);
}
else
{
return(0);
}
}
//Add vehicle method
protected internal static void AddVehicle(Vehicle.VehicleType vehicleType)
{
byte EntranceHour = byte.TryParse(Console.ReadLine(), out byte carEntranceHour) ? carEntranceHour : HourDefaultValue;
if (EntranceHour > 23)
{
ScreenMessages.PrintErrorMessage();
}
Vehicle vehicle;
if (vehicleType == Vehicle.VehicleType.Car)
{
Car NewCar = new Car(IdGenerator());
NewCar.EntryHour = EntranceHour;
vehicle = NewCar;
}
else
{
Bike NewBike = new Bike(IdGenerator());
NewBike.EntryHour = EntranceHour;
vehicle = NewBike;
}
ExistedVehicleList.Add(vehicle);
AllVehicleList.Add(vehicle);
Console.WriteLine($"New {vehicleType} saved by ID of {vehicle.ID}.\nPress any key to continue.");
}
public Inventory(Vehicle.VehicleType vehicleType, Vehicle vehicle, int count, int price)
{
VehicleType = vehicleType;
Count = count;
Price = price;
Vehicle = vehicle;
}
/*public Booking(DateTime startTime, DateTime endTime, Vehicle.VehicleType vehicleType)
* {
* Timeslot = new Timeslot(startTime, endTime);
* VehicleType = vehicleType;
* BookingId = new Guid().ToString();
* }*/
public bool Book(DateTime startTime, DateTime endTime, Vehicle.VehicleType vehicleType, string branchId)
{
System.Reflection.Assembly ass = System.Reflection.Assembly.GetEntryAssembly();
bookingStrategies = new List <IBookingStrategy>();
foreach (System.Reflection.TypeInfo ti in ass.DefinedTypes)
{
if (ti.ImplementedInterfaces.Contains(typeof(IBookingStrategy)))
{
bookingStrategies.Add(ass.CreateInstance(ti.FullName) as IBookingStrategy);
}
}
foreach (var bookingStrategy in bookingStrategies.OrderBy(x => x.Priority))
{
var availableInventories = bookingStrategy.GetInventory(branchId, Vehicle.GetSeatingCapacity(vehicleType));
var availableInventory = availableInventories.FirstOrDefault(x => x.Count > 0);
if (availableInventory?.Count == 0)
{
continue;
}
if (availableInventory?.Count > 0)
{
Timeslot = new Timeslot(startTime, endTime);
VehicleType = vehicleType;
BookingId = Guid.NewGuid().ToString();
return(true);
}
}
return(false);
}
public bool CanEngageWith(Track track, string vehicleName, bool considerLoaded = true, bool considerRange = true)
{
string trackTypeName = track.vehicleTypeName;
Vehicle.VehicleType trackVehicleType = Vehicle.sVehicleTypes[trackTypeName];
foreach (Launcher launcher in launchers)
{
if (launcher.vehicleNames.Contains(vehicleName) == false)
{
continue;
}
if (launcher.enabled == false)
{
continue;
}
if (launcher.vehicleCounts[launcher.vehicleNames.IndexOf(vehicleName)] <= 0 || (launcher.isLoaded == false && considerLoaded == true))
{
continue;
}
bool canEngage = Vehicle.sVehicleCanEngage[vehicleName][(int)trackVehicleType];
bool canBeEngaged = Vehicle.sVehicleCanBeEngaged[track.vehicleTypeName][(int)Vehicle.sVehicleTypes[vehicleName]];
if (canEngage && canBeEngaged)
{
float range = Vector3.Distance(self.position, track.predictedPosition);
if (range <= Vehicle.sVehicleRanges[vehicleName] || considerRange == false)
{
return(true);
}
}
}
return(false);
}
public static EnergySystem GetElectricSystem(Vehicle.VehicleType i_VehicleType)
{
batteryInformationLable();
EnergySystem energySystem = new ElectricSystem(
getMaximumBatteryWorkingTime2(i_VehicleType),
getCurrentBatteryStorage(getMaximumBatteryWorkingTime2(i_VehicleType)));
return(energySystem);
}
private static void checkVehicleType(string i_VehicleTypeFormatString, ref Vehicle.VehicleType io_VehicleType)
{
if (i_VehicleTypeFormatString != "1" && i_VehicleTypeFormatString != "2" && i_VehicleTypeFormatString != "3")
{
throw new FormatException(string.Format("Bad Selection Chose One Number From (1-3) {0}", Environment.NewLine));
}
io_VehicleType = (Vehicle.VehicleType) int.Parse(i_VehicleTypeFormatString);
}
public static EnergySystem GetFuelSystem(Vehicle.VehicleType i_VehicleType)
{
fuelInformationLable();
EnergySystem energySystem = new FuelSystem(
getAutomatedFuelType(i_VehicleType),
getMaximumFuelAmount(i_VehicleType),
getCurrentFuelAmount(getMaximumFuelAmount(i_VehicleType)));
return(energySystem);
}
private static List <Wheel> getVehicleWheels(short i_WheelsNumber, Vehicle.VehicleType i_VehicleType)
{
List <Wheel> vehicleWheels = new List <Wheel>();
for (int i = 0; i < i_WheelsNumber; i++)
{
vehicleWheels.Add(WheelUI.GetOneWheel(i + 1, i_VehicleType));
}
return(vehicleWheels);
}
private void DespawnEvent(VehicleDespawnEvent eve)
{
Vehicle.VehicleType vehicleType = eve.Vehicle.type;
if (vehicleType == Vehicle.VehicleType.Car)
{
activeCarCount--;
}
else
{
activeBikeCount--;
}
Destroy(eve.Vehicle.gameObject);
SpawnVehicle();
print(eve.Description);
}
private static float getMaximumBatteryWorkingTime2(Vehicle.VehicleType i_VehicleType)
{
float maximumBatteryWorkingTime;
if (i_VehicleType == Vehicle.VehicleType.Car)
{
maximumBatteryWorkingTime = InputInstructions.CarMaxBatteryTime;
}
else
{
maximumBatteryWorkingTime = InputInstructions.MotorcycleMaxBatteryTime;
}
return(maximumBatteryWorkingTime);
}
public string FindBestVehicleFor(Track track, bool considerRange = true)
{
List <string> candidates = new List <string>();
string trackTypeName = track.vehicleTypeName;
Vehicle.VehicleType trackVehicleType = Vehicle.sVehicleTypes[trackTypeName];
foreach (string vehicle in vehicles)
{
if (vehicleCounts[vehicles.IndexOf(vehicle)] <= 0 || (airStrips.Any((Airstrip a) => a.CanTakeOff(vehicle, false)) == false))
{
continue;
}
bool canEngage = Vehicle.sVehicleTaskTypes[vehicle].Any((Vehicle.VehicleType t) => t == trackVehicleType);
if (canEngage)
{
float eta = Vector3.Distance(self.position, track.predictedPositionAtTime(0)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
eta = Vector3.Distance(self.position, track.predictedPositionAtTime(eta)) / Vehicle.sVehicleMaxSpeed[vehicle] / 0.9f;
float range = Vector3.Distance(self.position, track.predictedPositionAtTime(eta));
if (range <= Vehicle.sVehicleRanges[vehicle] / 2.5f || considerRange == false)
{
if (candidates.Contains(vehicle) == false)
{
candidates.Add(vehicle);
}
}
}
}
if (candidates.Count == 0)
{
return("");
}
else
{
int index = UnityEngine.Random.Range(0, candidates.Count);
return(candidates[index]);
}
}
private void RemoveVehicle(Vehicle.VehicleType vehicleType, int count)
{
if (Inventory.Any(x => x.VehicleType.Equals(vehicleType)))
{
foreach (var x in Inventory)
{
if (x.VehicleType.Equals(vehicleType))
{
if (x.Count >= count)
{
x.Count -= count;
break;
}
}
}
}
}
private static FuelSystem.FuelType getAutomatedFuelType(Vehicle.VehicleType i_VehicleType)
{
FuelSystem.FuelType fuelType;
if (i_VehicleType == Vehicle.VehicleType.Car)
{
fuelType = InputInstructions.CarFuelType;
}
else if (i_VehicleType == Vehicle.VehicleType.Motorcycle)
{
fuelType = InputInstructions.MotorcycleFuelType;
}
else
{
fuelType = InputInstructions.TruckFuelType;
}
return(fuelType);
}
public void AddNewVehicle(Vehicle.VehicleType vehicleType, int count, int price)
{
if (Inventory.Any(x => x.VehicleType.Equals(vehicleType)))
{
foreach (var x in Inventory)
{
if (x.VehicleType.Equals(vehicleType))
{
x.Count += count;
}
}
}
else
{
Vehicle vehicle = new Vehicle(vehicleType);
Inventory.Add(new Inventory(vehicleType, vehicle, count, price));
}
}
private static float getMaximumAirPressure2(Vehicle.VehicleType i_VehicleType)
{
float maximumAirPressure;
if (i_VehicleType == Vehicle.VehicleType.Car)
{
maximumAirPressure = InputInstructions.MaxCarWheelAirPressure;
}
else if (i_VehicleType == Vehicle.VehicleType.Motorcycle)
{
maximumAirPressure = InputInstructions.MaxMotorcycleAirPressure;
}
else
{
maximumAirPressure = InputInstructions.MaxTruckAirPressure;
}
return(maximumAirPressure);
}
private static short getVehicleWheelsNumber(Vehicle.VehicleType i_VehicleType)
{
short wheelsNumber;
if (i_VehicleType == Vehicle.VehicleType.Motorcycle)
{
wheelsNumber = InputInstructions.MotorcycleWheelsNumber;
}
else if (i_VehicleType == Vehicle.VehicleType.Car)
{
wheelsNumber = InputInstructions.CarWheelsNumber;
}
else
{
wheelsNumber = InputInstructions.TruckWheelNumber;
}
return(wheelsNumber);
}
private static Vehicle.VehicleType getVehicleType()
{
Vehicle.VehicleType vehicleType = 0;
vehicleTypeInputMessage();
string vehicleTypeStringFormat = Console.ReadLine();
try
{
checkVehicleType(vehicleTypeStringFormat, ref vehicleType);
}
catch (FormatException ex)
{
Console.WriteLine(ex.Message);
vehicleTypesInstructionMessage();
vehicleType = getVehicleType();
}
return(vehicleType);
}
private static float getMaximumFuelAmount(Vehicle.VehicleType i_VehicleType)
{
float maximumFuelAmount;
if (i_VehicleType == Vehicle.VehicleType.Car)
{
maximumFuelAmount = InputInstructions.CarMaxTank;
}
else if (i_VehicleType == Vehicle.VehicleType.Motorcycle)
{
maximumFuelAmount = InputInstructions.MotorcycleMaxTank;
}
else
{
maximumFuelAmount = InputInstructions.TruckMaxTank;
}
return(maximumFuelAmount);
}
public Vehicle CreateVehicle(Vehicle.VehicleType vehicle, Vehicle.Heading heading)
{
Vehicle newVehicle = null;
if (vehicleType.Equals(Vehicle.VehicleType.Car))
{
newVehicle = new Car(heading);
}
if (vehicleType.Equals(Vehicle.VehicleType.Truck))
{
newVehicle = new Truck(heading);
}
this.VehicleDirection = heading;
if (heading.Equals(Vehicle.Heading.Right))
{
this.flipHorizontally();
}
return
}
public static Vehicle GetNewMotorcycle(
ref Client i_Owner,
Vehicle.VehicleType i_VehicleType,
string i_VehicleModel,
string i_VehicleLicenseNumber,
ref EnergySystem i_VehicleEnergySystem,
short i_WheelsNumber,
ref List <Wheel> i_VehicleWheels)
{
additionalMotorcycleInformationLabel();
return(CreateNewVehicle.CreateNewMotorcycle(
ref i_Owner,
i_VehicleType,
i_VehicleModel,
i_VehicleLicenseNumber,
ref i_VehicleEnergySystem,
i_WheelsNumber,
ref i_VehicleWheels,
getEngineCapacity(),
getLicenseType()));
}
public static Vehicle GetNewTruck(
ref Client i_Owner,
Vehicle.VehicleType i_VehicleType,
string i_VehicleModel,
string i_VehicleLicenseNumber,
ref EnergySystem i_VehicleEnergySystem,
short i_WheelsNumber,
ref List <Wheel> i_VehicleWheels)
{
additionalTruckInformationLabel();
return(CreateNewVehicle.CreatNewTruck(
ref i_Owner,
i_VehicleType,
i_VehicleModel,
i_VehicleLicenseNumber,
ref i_VehicleEnergySystem,
i_WheelsNumber,
ref i_VehicleWheels,
getcargoVolume(),
cargoDangerousMaterials()));
}
public static Vehicle GetNewCar(
ref Client i_Owner,
Vehicle.VehicleType i_VehicleType,
string i_VehicleModel,
string i_VehicleLicenseNumber,
ref EnergySystem i_VehicleEnergySystem,
short i_WheelsNumber,
ref List <Wheel> i_VehicleWheels)
{
additionalCarInformationLabel();
return(CreateNewVehicle.CreateNewCar(
ref i_Owner,
i_VehicleType,
i_VehicleModel,
i_VehicleLicenseNumber,
ref i_VehicleEnergySystem,
i_WheelsNumber,
ref i_VehicleWheels,
getCarColor(),
getCarDoors()));
}
public static Vehicle CreateNewCar(
ref Client i_Owner,
Vehicle.VehicleType i_Type,
string i_ModelName,
string i_LicenseNumber,
ref EnergySystem i_EnergySystem,
short i_WheelsNumber,
ref List <Wheel> i_Wheels,
Car.CarColor i_CarColor,
Car.CarDoors i_DoorsNumber)
{
return(new Car(
ref i_Owner,
i_Type,
i_ModelName,
i_LicenseNumber,
ref i_EnergySystem,
i_WheelsNumber,
ref i_Wheels,
i_CarColor,
i_DoorsNumber));
}
public static Truck CreatNewTruck(
ref Client i_Owner,
Vehicle.VehicleType i_Type,
string i_ModelName,
string i_LicenseNumber,
ref EnergySystem i_EnergySystem,
short i_WheelsNumber,
ref List <Wheel> i_Wheels,
float i_CargoVolume,
bool i_CargoDangerousMaterials)
{
return(new Truck(
ref i_Owner,
i_Type,
i_ModelName,
i_LicenseNumber,
ref i_EnergySystem,
i_WheelsNumber,
ref i_Wheels,
i_CargoVolume,
i_CargoDangerousMaterials));
}
public static Motorcycle CreateNewMotorcycle(
ref Client i_Owner,
Vehicle.VehicleType i_Type,
string i_ModelName,
string i_LicenseNumber,
ref EnergySystem i_EnergySystem,
short i_WheelsNumber,
ref List <Wheel> i_Wheels,
int i_EngineCapacity,
Motorcycle.LicenseType i_LicenseType)
{
return(new Motorcycle(
ref i_Owner,
i_Type,
i_ModelName,
i_LicenseNumber,
ref i_EnergySystem,
i_WheelsNumber,
ref i_Wheels,
i_EngineCapacity,
i_LicenseType));
}
//public void RemoveVehicle(string vehicleId)
//{
// foreach(var inventory in Inventory)
// {
// if (inventory.Vehicle.VehicleId.Equals(vehicleId))
// {
// if (inventory.Count > 0)
// {
// inventory.Count--;
// break;
// }
// }
// }
//}
public string AddNewBooking(DateTime startTime, DateTime endTime, Vehicle.VehicleType VehicleType)
{
var currentDateTime = DateTime.Now;
if (DateTime.Compare(currentDateTime, startTime) > 0 || DateTime.Compare(startTime, endTime) > 0)
{
throw new ArgumentOutOfRangeException("Starttime and Endtime are not in future or Endtime falls before Starttime");
}
else
{
var booking = new Booking();
var bookingDone = booking.Book(startTime, endTime, VehicleType, BranchId);
if (bookingDone)
{
Bookings.Add(booking);
RemoveVehicle(VehicleType, 1);
return(booking.BookingId);
}
return(Constants.NoBooking);
}
}
public static EnergySystem GetNewEnergySystem(Vehicle.VehicleType i_VehicleType)
{
EnergySystem energySystem;
if (i_VehicleType != Vehicle.VehicleType.Truck)
{
if (getEnergySystem() == EnergySystemType.Fuel)
{
energySystem = FuelSystemUI.GetFuelSystem(i_VehicleType);
}
else
{
energySystem = ElectricSystemUI.GetElectricSystem(i_VehicleType);
}
}
else
{
energySystem = FuelSystemUI.GetFuelSystem(i_VehicleType);
}
return(energySystem);
}
static async Task Main(string[] args)
{
Menu menu = new Menu();
menu.AddMenuItems();
Vehicle vehicle;
decimal ListPrice;
string FirstName;
string LastName;
string Make;
string Model;
int Year;
string Type;
string Email;
Console.WriteLine(menu.MenuItems[0]);
Console.WriteLine(menu.MenuItems[1]);
FirstName = Console.ReadLine();
Console.WriteLine(menu.MenuItems[2]);
LastName = Console.ReadLine();
Console.WriteLine(menu.MenuItems[3]);
Email = Console.ReadLine();
Console.WriteLine(menu.MenuItems[4]);
Type = Console.ReadLine();
Console.WriteLine(menu.MenuItems[5]);
Make = Console.ReadLine();
Console.WriteLine(menu.MenuItems[6]);
Model = Console.ReadLine();
Console.WriteLine(menu.MenuItems[7]);
Year = int.Parse(Console.ReadLine());
Vehicle.VehicleType VehicleEnum = VehicleData.GetVehicleType(Type);
ListPrice = VehicleData.GetPrice(VehicleEnum);
vehicle = new Vehicle(Make, Model, Convert.ToInt32(Year), ListPrice, FirstName, LastName, Email, VehicleEnum);
//Console.WriteLine(VehicleEnum.ToString());
await HttpTrigger.HttpResponse(vehicle);
}
