private GenericGA CreateGeneticAlgorithm(List <float> seed = null)
{
var geneticAlgorithm = new GenericGA();
var carConfiguration = new CarConfiguration();
geneticAlgorithm.CreateIndividual = () =>
{
return(GAHelpers.SpawnCarController(carConfiguration, random, seed));
};
geneticAlgorithm.CrossoverIndividuals = (a, b) =>
{
return(GAHelpers.DoCrossover(a, b, random));
};
geneticAlgorithm.CrossoverEnabled = true;
geneticAlgorithm.MutationEnabled = true;
geneticAlgorithm.MutateParentsAsChildren = true;
geneticAlgorithm.PopulationCount = 100;
geneticAlgorithm.SpawnPopulation();
return(geneticAlgorithm);
}
// Main Configurator page where users can configure the car of their dreams.
// Input:
// - (int) id: Car Id from DBContext
public ActionResult Build(int id = 0)
{
var car = _context.Cars.SingleOrDefault(c => c.Id == id);
if (car == null)
{
return(HttpNotFound());
}
var engines = _context.Engines.ToList();
var paints = _context.Paints.ToList();
var rims = _context.Rims.ToList();
var extras = _context.Extras.ToList();
var carConfiguration = new CarConfiguration
{
CarID = car.Id,
};
var configViewModel = new CarConfigViewModel
{
Car = car,
Engines = engines,
Paints = paints,
Rims = rims,
Extras = extras,
CarConfiguration = carConfiguration,
};
return(View(configViewModel));
}
public void WhenCloningGetTotalPriceShouldReturnProperValue()
{
var configurationList = new CarConfigurationManager();
var bmw = new CarModel()
{
Name = "BMW",
BasePrice = 100000
};
var engineUpgrade = new CarPart()
{
Name = "V12",
Price = 50000
};
var breaksUpgrade = new CarPart()
{
Name = "ExtraBreaks",
Price = 20000
};
var configuration = new CarConfiguration("BMWV12", bmw, new List <CarPart>()
{
engineUpgrade, breaksUpgrade
});
configurationList["BMWV12"] = configuration;
var clonedConfiguration = configurationList["BMWV12"].Clone() as CarConfiguration;
clonedConfiguration.GetTotalPrice().Should().Be(configuration.GetTotalPrice());
}
public static void GetCarConfigurationEntity(RaceTrack raceTrack, out Guid trackId, out double fuelCapacity, out TimeSpan timePerLap, out double fuelConsumptionPerLap, out CarConfiguration carConfig)
{
trackId = raceTrack.TrackId;
fuelCapacity = 20;
timePerLap = new TimeSpan(1800);
fuelConsumptionPerLap = 5;
carConfig = new CarConfiguration(raceTrack, fuelCapacity, timePerLap, fuelConsumptionPerLap);
}
public Car(string color = "blue", CarConfiguration configuration = CarConfiguration.Sedan,
float weight = 1971, float horsePower = 400, float length = 4.5f, float width = 2.2f, float height = 1.1f, bool isDestroyed = false)
: base("car", color, 4, weight, length, width, height)
{
Configuration = configuration;
HorsePower = horsePower;
IsDestroyed = isDestroyed;
MeasureResults();
}
public static IIndividual SpawnCarController(
CarConfiguration carConfiguration,
Random random,
List <float> initialWeights = null)
{
var networkStructure = new int[] { carConfiguration.NumberOfRays, 12, 12, 4 };
var controller = new CarAI(networkStructure, random, initialWeights);
controller.Initalize(carConfiguration);
return(controller);
}
public OfferDto CreateOffer(CarConfigurationDto dto)
{
var carConfiguration = new CarConfiguration(dto.Model, new Engine(dto.EngineCode, dto.EngineType, dto.EngineCapacity), new Gearbox(dto.GearboxGears, dto.GearboxType), dto.Version, dto.Color);
var price = this.priceCalculationService.CalculatePrice(carConfiguration);
var offer = new Offer(carConfiguration, price);
this.offersRepository.Add(offer);
this.unitOfWork.Commit();
this.logger.Info($"Offer created [Id = {offer.Id}]");
return(new OfferDto(offer));
}
public Offer(CarConfiguration configuration, decimal price)
{
if (configuration == null)
{
throw new ArgumentException(nameof(configuration));
}
Id = Guid.NewGuid();
Configuration = configuration;
TotalPrice = price;
CreationDate = DateTime.Now;
ExpirationDate = CreationDate.AddMonths(DEFAULT_EXPIRATION_TIME_IN_MONTHS);
}
public void Given_CarConfiguration_When_CreateOffer_Then_CreatesValidObject()
{
//arrange
var carConfiguration = new CarConfiguration("Octavia", new Engine("TSI_2_0_GEN3", EngineType.Petrol, 1984), new Gearbox(6, GearboxType.Automatic),
EquipmentVersion.Limited, CarColor.RaceBlue);
//act
var offer = new Offer(carConfiguration, 150000M);
//assert
Assert.IsNotNull(offer);
Assert.AreEqual(carConfiguration, offer.Configuration);
Assert.AreEqual(150000M, offer.TotalPrice);
}
public CarHuman(bool captureState, int frequencyMs)
{
this.captureState = captureState;
this.frequencyMs = frequencyMs / 1000.0f;
StateInputMeasurements = new List <float[]>();
StateOutputMeasurements = new List <float[]>();
var controllerManager = new ControllerManager();
gameController = controllerManager.GetController();
// Default the car configuration. Rarely ever changed, not even sure this needs to be exposed.
Configuration = new CarConfiguration();
}
public App()
{
InitializeComponent();
CurrentCarConfiguration = new CarConfiguration();
var navigationPage = new NavigationPage(new MainPage());
navigationPage.BarBackgroundColor = Color.FromHex("#403D58");
navigationPage.BarTextColor = Color.White;
navigationPage.BackgroundColor = Color.FromHex("#F2EFEA");
MainPage = navigationPage;
}
public ActionResult Create(CarConfiguration carConfiguration)
{
var guid = Guid.NewGuid();
carConfiguration.Guid = guid;
_context.CarConfigurations.Add(carConfiguration);
_context.SaveChanges();
var successurl = Url.Action("Load", "CarConfigurator", new { guid = guid });
return(Json(new { redirecturl = successurl }));
//return RedirectToAction("Load", new { guid = guid });
}
static async Task Main(string[] args)
{
RaceTrack raceTrack = new RaceTrack(1000, 3, new TimeSpan(TimeSpan.TicksPerSecond * 20));
long seconds = TimeSpan.TicksPerSecond * 60;
TimeSpan timePerLap = new TimeSpan(seconds); // 60 seconds per lap
CarConfiguration carConiguration = new CarConfiguration(raceTrack, 20, timePerLap, 40);
RaceCar car1 = new RaceCar(carConiguration);
RaceCar car2 = new RaceCar(carConiguration);
List <RaceCar> raceCars = new List <RaceCar>();
Console.WriteLine($"Current Thread Id: {Thread.CurrentThread.ManagedThreadId}");
raceCars.Add(car1);
raceCars.Add(car2);
//await RunAll(raceCars);
await RunAllParalle(raceCars);
}
protected void InstantiateCar(int index)
{
GameObject newCar = GameObject.Instantiate(carPrefab, spawnPoint.position + spawnPoint.right * index * 5, spawnPoint.rotation);
PlayerController playerController = newCar.GetComponent <PlayerController>();
playerController.id = index;
playerController.SetCarColor(colors[index]);
CarConfiguration newConfiguration = new CarConfiguration();
newConfiguration.carController = playerController;
newConfiguration.id = index;
newConfiguration.color = colors[index];
newConfiguration.colorName = colorsName[index];
newConfiguration.dangerCounter = maxTimeOutside;
cars.Add(newConfiguration);
}
public async Task <double> PredictPrice(CarConfiguration configuration)
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
var scoreRequest = new CarPriceScoreRequest(configuration);
var json = JsonConvert.SerializeObject(scoreRequest);
var content = new StringContent(json);
var response = await httpClient.PostAsync("https://ussouthcentral.services.azureml.net/workspaces/8a54fb6daa8b4ce5a77212d3976d677f/services/67a5b6c0e92b424c8e4dad7048ace755/execute?api-version=2.0&format=swagger", content);
if (response.IsSuccessStatusCode)
{
var jsonResult = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <CarPriceScoreResult>(jsonResult);
return(Convert.ToDouble(result.Results.PriceEstimation.First().ScoredLabels));
}
return(0);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
var carConf = new CarConfiguration();
Configuration.Bind("Car", carConf);
services.AddSingleton(carConf);
//both are same, addoptions method is more specific
// services.Configure<CarConfiguration>(Configuration.GetSection("Car"));
services.AddOptions <CarConfiguration>().Bind(Configuration.GetSection("Car"));
//-----------------------------------------------
services.AddCors(options =>
{
options.AddPolicy("AllowAnyOrigin", builder =>
{
builder.AllowAnyOrigin();
builder.AllowAnyMethod();
builder.AllowAnyHeader();
builder.WithExposedHeaders("PageNumber", "PageSize", "PageCount", "TotalRecords"); //this makes mentioned headers' values accessible in client side
});
options.AddPolicy("RestrictedRequest", builder =>
{
builder.WithOrigins("http://localhost:8080");
}); //restricted Origin Cors Policy
options.AddPolicy("RestrictedMethodAndHeader", builder =>
{
builder.AllowAnyOrigin();
builder.WithMethods("Get");
builder.WithHeaders("Content-Type");
}); // restricted Method and Header Cors Policy
options.AddPolicy("PreflightRequestCache", builder =>
{
builder.WithOrigins("http://localhost:8080").AllowAnyHeader().SetPreflightMaxAge(TimeSpan.FromMinutes(1));
}); //added time for preflight request cache, after 1 minute there will be new preflight request to send server before actual request
});
}
A_new_configuration_with_black_sapphire_metallic_color_is_created(CarConfiguration carConfiguration)
{
return(carConfiguration, carConfiguration.WithExteriorColor(ExteriorColor.Black_sapphire_metallic));
}
private void CarEntityConfiguraion(ModelBuilder modelBuilder)
{
var config = new CarConfiguration();
config.CarEntityConfiguration(modelBuilder);
}
public void Initalize(CarConfiguration configuration)
{
this.Configuration = configuration;
}
public decimal CalculatePrice(CarConfiguration carConfiguration)
{
//in real life here we can call external service responsible for price calculation
return(new Random().Next(50000, 200000));
}
private void Has_alpine_white_exterior_color(CarConfiguration configuration)
{
configuration.ExteriorColor.Should().Be(ExteriorColor.Alpine_white);
}
public WeatherForecastController(ILogger <WeatherForecastController> logger, IOptions <CarConfiguration> configurationSingletion, CarConfiguration carConfiguration,
IOptionsSnapshot <CarConfiguration> carConfigurationTransient)
{
_logger = logger;
this.carConfiguration = carConfigurationTransient.Value;
}
