/// <summary> /// Creates/starts a rollup/simulation /// </summary> /// <param name="model">SimulationModel</param> /// <returns>string Task</returns> public Task <string> RunSimulation(SimulationModel model) { try { var connectionString = ConfigurationManager.ConnectionStrings["BridgeCareContext"].ConnectionString; DBMgr.NativeConnectionParameters = new ConnectionParameters(connectionString, false, "MSSQL"); #if DEBUG var mongoConnection = Settings.Default.MongoDBDevConnectionString; #else var mongoConnection = Settings.Default.MongoDBProdConnectionString; #endif var simulation = new Simulation.Simulation(model.SimulationName, model.NetworkName, model.SimulationId, model.NetworkId, mongoConnection); Thread simulationThread = new Thread(new ParameterizedThreadStart(simulation.CompileSimulation)); simulationThread.Start(true); return(Task.FromResult("Simulation running...")); } catch (Exception ex) { DBMgr.CloseConnection(); return(Task.FromResult($"Simulation run failed::{ex.Message}")); } }
private void StartSimulation() { _sheetController.DeselectAll(); try { if (simulation == null) { var block = _sheetController.State.ContentBlock; var serializer = new Simulation.Serializer(); var solution = serializer.Serialize(block); simulation = new Simulation.Simulation(solution, 100); simulation.Start(new WpfUpdate()); var window = new Window() { Title = "Tags", Width = 300, Height = 500, WindowStartupLocation = WindowStartupLocation.CenterScreen }; window.Owner = this; window.Content = new TagsControl(); window.DataContext = solution.Tags; window.Show(); } } catch (Exception ex) { Debug.Print(ex.Message); Debug.Print(ex.StackTrace); } }
public void EmitOnSimulationRemoval(Simulation.Simulation simulation, EntityRemovalReason?reason) { foreach (EntityComponent simulationComponent in EntityComponents) { simulationComponent?.OnSimulationRemove(simulation, this, reason); } }
public RoutingDataModel CreateFixedDataModel(Simulation.Simulation simulation) //test and debug { List <Vehicle> dataModelVehicles = new List <Vehicle>(); int numberVehicles = 1; List <long> startDepotsArrivalTime = new List <long>(numberVehicles); //Creates two available vehicles to be able to perform flexible routing for the pdtwdatamodel for (int i = 0; i < numberVehicles; i++) { var vehicle = new Vehicle(simulation.Params.VehicleSpeed, simulation.Params.VehicleCapacity, simulation.Context.Depot, simulation.Context.Depot); dataModelVehicles.Add(vehicle); startDepotsArrivalTime.Add(0);//startDepotArrival time = 0 for all the vehicles } var customersToBeServed = new List <Customer>(); customersToBeServed.Add(new Customer(new Stop[] { simulation.Context.Stops[1], simulation.Context.Stops[2] }, new long[] { 600, 1600 }, 0, false)); customersToBeServed.Add(new Customer(new Stop[] { simulation.Context.Stops[5], simulation.Context.Stops[3] }, new long[] { 1000, 2000 }, 0, false)); //customersToBeServed.Add(new Customer(new Stop[] { TransportationNetwork.Stops[5], TransportationNetwork.Stops[4] }, new long[] { 800,3500 }, 0)); //customersToBeServed.Add(new Customer(new Stop[] { TransportationNetwork.Stops[8], TransportationNetwork.Stops[9] }, new long[] {3000, 5000 }, 0)); var indexManager = new DataModelIndexManager(dataModelVehicles, customersToBeServed, startDepotsArrivalTime); var routingDataModel = new RoutingDataModel(indexManager, simulation.Params.MaximumRelativeCustomerRideTime, simulation.Params.MaximumAllowedDeliveryDelay); return(routingDataModel); }
public static void Main(string[] args) { var circuitName = "simple-circuit"; var circuitPath = Path.GetFullPath($"{assetsDirectoryPath}/tracks/{circuitName}"); var perceptionPeriod = TimeSpan.FromSeconds(1.0 / 10.0); var simulationStep = TimeSpan.FromSeconds(1.0 / 20.0); Console.WriteLine($"Loading track {circuitName}"); var track = Track.Load($"{circuitPath}/circuit_definition.json"); var world = new StandardWorld(track, simulationStep, safetyMargin: 0.5); var planName = "plan-HybridAStarPlanner-1551383968-15200.json"; Console.WriteLine($"Loading plan {planName}"); var plan = Plans.Load($"{assetsDirectoryPath}/plans/{planName}"); var trajectory = new Trajectory(plan.Trajectory); var agent = new DynamcWindowApproachAgent( trajectory, world, 4 * world.VehicleModel.Length, perceptionPeriod, 4 * perceptionPeriod); //var agent = new PIDAgent(plan.Trajectory, world.MotionModel, perceptionPeriod); Console.WriteLine($"Simulating agent {agent.GetType().Name}"); var simulation = new Simulation.Simulation(agent, world); var summary = simulation.Simulate(simulationStep, perceptionPeriod, TimeSpan.FromSeconds(60)); IO.Simulation.StoreResult(track, world.VehicleModel, summary, $"{circuitPath}/visualization.svg", "C:/Users/simon/Projects/racer-experiment/simulator/src/report.json"); Console.WriteLine($"Time to finish: {summary.SimulationTime.TotalSeconds}s"); }
private void UpdateVisibleChunks(Simulation.Simulation simulation) { //Clear visible chunks so we dont have to figure out which chunks are no longer being seen VisibleChunks.Clear(); Chunk rootChunk = simulation.World.ChunkIndex[ChunkKey]; //find the chunks that the player is currently simulating for (int y = rootChunk.ChunkY - simulation.SimulationDistance; y < rootChunk.ChunkY + simulation.SimulationDistance; y++) { for (int x = rootChunk.ChunkX - simulation.SimulationDistance; x < rootChunk.ChunkX + simulation.SimulationDistance; x++) { //Get a chunk if it exist at the location Chunk visibleChunk; if ((visibleChunk = simulation.World.ChunkFromChunkLocation(x, y)) == null) { continue; } //Add chunk to visible chunks VisibleChunks.Add(visibleChunk.ChunkKey); //update chunk history if new with a negative number so a full chunk update will be forced if (!ChunkVersions.ContainsKey(visibleChunk.ChunkKey)) { ChunkVersions[visibleChunk.ChunkKey] = -1; } } } }
private static void WorldBoundaryCheck(Simulation.Simulation simulation, SimulationEntity entity) { //World Boundaries if (entity.Position.X < 0) { if (entity.EmitOnWorldBoundaryCollision(simulation, CollisionSide.LeftBorder)) { entity.Position.X = entity.OldPosition.X = 0; entity.Velocity.X = 0; } } if (entity.Position.X > simulation.World.MapPixelWidth() - entity.Dimensions.X) { if (entity.EmitOnWorldBoundaryCollision(simulation, CollisionSide.RightBorder)) { entity.Position.X = entity.OldPosition.X = simulation.World.MapPixelWidth() - entity.Dimensions.X; entity.Velocity.X = 0; } } if (entity.Position.Y < 0) { entity.EmitOnWorldBoundaryCollision(simulation, CollisionSide.TopBorder); } if (entity.Position.Y > simulation.World.MapPixelHeight()) { entity.EmitOnWorldBoundaryCollision(simulation, CollisionSide.BottomBorder); } }
public static void PlayerDisconnected(this Simulation.Simulation simulation, int photonPlayerId) { simulation.EnqueueCommand(new PlayerDisconnectedCommand { PlayerExternalId = photonPlayerId }); }
private static void EntityCollisions(Simulation.Simulation simulation, SimulationEntity entity) { foreach (SimulationEntity targetEntity in simulation.World.QueryEntities(entity.Bounds, entity.CollideWithFilters, entity.EntityId)) { if (targetEntity.EntityId != entity.EntityId) { entity.EmitOnEntityCollision(simulation, targetEntity); } } }
public void UseItemRightClick(Simulation.Simulation simulation, SimulationEntity entity) { if (Configuration.RightClickComponents.Count == 0) { return; } foreach (string componentKey in Configuration.RightClickComponents) { ConfigurationRegistry.GetInstance().GetItemComponent(componentKey).Use(simulation, entity, this); } }
public bool EmitOnTileCollision(Simulation.Simulation simulation, TileCollision tc) { bool defaultAction = true; foreach (EntityComponent simulationComponent in EntityComponents) { if (!simulationComponent.OnTileCollision(simulation, this, tc)) { defaultAction = false; } } return(defaultAction); }
public bool EmitOnWorldBoundaryCollision(Simulation.Simulation simulation, CollisionSide side) { bool defaultAction = true; foreach (EntityComponent simulationComponent in EntityComponents) { if (!simulationComponent.OnWorldBoundaryCollision(simulation, this, side)) { defaultAction = false; } } return(defaultAction); }
public void UseItemLeftClick(Simulation.Simulation simulation, SimulationEntity entity) { if (Configuration.LeftClickComponents.Count == 0) {//Do default actions if no specified item components ConfigurationRegistry.GetInstance().GetItemComponent("Hit").Use(simulation, entity, this); ConfigurationRegistry.GetInstance().GetItemComponent("BreakBlock").Use(simulation, entity, this); return; } foreach (string componentKey in Configuration.LeftClickComponents) { ConfigurationRegistry.GetInstance().GetItemComponent(componentKey).Use(simulation, entity, this); } }
/// <summary> /// /// </summary> /// <param name="simulation"></param> /// <param name="entity"></param> public static void DetectCollision(Simulation.Simulation simulation, SimulationEntity entity) { WorldBoundaryCheck(simulation, entity); EntityCollisions(simulation, entity); if (!entity.CollideWithFilters?.Contains("tile") ?? false) { return; } //Left and right tile collisions BroadPhaseHorizontal(simulation, entity); //Detect up and down tile collisions BroadPhaseVertical(simulation, entity); }
public void UseItemRightHold(Simulation.Simulation simulation, SimulationEntity entity, int holdTicks) { if (holdTicks % Configuration.CoolDown != 0) { return; } if (Configuration.RightHoldComponents.Count == 0) { return; } foreach (string componentKey in Configuration.RightHoldComponents) { ConfigurationRegistry.GetInstance().GetItemComponent(componentKey).Use(simulation, entity, this); } }
private static void BroadPhaseVertical(Simulation.Simulation simulation, SimulationEntity entity) { float tileSize = simulation.World.WorldOptions.WorldScale; if (entity.Position.Y - entity.OldPosition.Y > 0) {//movin down TileCollision tc = GetTileCollisionTemplate(entity, CollisionSide.TopBorder, tileSize); //in between bounds corners for (int i = tc.LeftBlockX; i <= tc.RightBlockX; i++) { if ((tc.Tile = simulation.World.GetBlock(i, tc.BottomBlockY)) == 0) { continue; } tc.TilePosition.X = i; if (TopBorderCollision(simulation, entity, tc)) { return; } } } else if (entity.Position.Y - entity.OldPosition.Y < 0) {//move up TileCollision tc = GetTileCollisionTemplate(entity, CollisionSide.BottomBorder, tileSize); //in between bounds corners for (int i = tc.LeftBlockX; i <= tc.RightBlockX; i++) { if ((tc.Tile = simulation.World.GetBlock(i, tc.TopBlockY)) == 0) { continue; } tc.TilePosition.X = i; if (BottomBorderCollision(simulation, entity, tc)) { return; } } } }
private void StopSimulation() { try { if (simulation != null) { simulation.Stop(); simulation = null; } } catch (Exception ex) { Debug.Print(ex.Message); Debug.Print(ex.StackTrace); } _sheetController.DeselectAll(); }
private static void BroadPhaseHorizontal(Simulation.Simulation simulation, SimulationEntity entity) { float tileSize = simulation.World.WorldOptions.WorldScale; if (entity.Position.X - entity.OldPosition.X < 0) //works now :D { //Left step this time TileCollision tc = GetTileCollisionTemplate(entity, CollisionSide.RightBorder, tileSize); for (int i = tc.TopBlockY; i <= tc.BottomBlockY; i++) { if ((tc.Tile = simulation.World.GetBlock(tc.LeftBlockX, i)) == 0) { continue; } tc.TilePosition.Y = i; if (RightBorderCollision(simulation, entity, tc)) { return; } } } else if (entity.Position.X - entity.OldPosition.X > 0) //Works dont touch!! { //Right step this time TileCollision tc = GetTileCollisionTemplate(entity, CollisionSide.LeftBorder, tileSize); for (int i = tc.TopBlockY; i <= tc.BottomBlockY; i++) { if ((tc.Tile = simulation.World.GetBlock(tc.RightBlockX, i)) == 0) { continue; } tc.TilePosition.Y = i; if (LeftBorderCollision(simulation, entity, tc)) { return; } } } }
private void MoveEntity(Simulation.Simulation simulation) { //Place entity in correct chunk if in new position string chunkKey = simulation.World.ChunkFromPixelLocation((int)Position.X, (int)Position.Y) ?.ChunkKey; if (chunkKey != ChunkKey && chunkKey != null) { simulation.World.MoveEntity(EntityId, simulation.World.ChunkIndex[ChunkKey], simulation.World.ChunkIndex[chunkKey]); ChunkKey = chunkKey; } if (EntityType != EntityType.Player || ChunkKey == null) { return; } UpdateVisibleChunks(simulation); }
private static bool RightBorderCollision(Simulation.Simulation simulation, SimulationEntity entity, TileCollision tc) { int tileSize = simulation.World.WorldOptions.WorldScale; //if entity is not moving left if (!(entity.Position.X - entity.OldPosition.X < 0)) { return(false); } Rectangle block = tc.TileRectangle(tileSize); if (entity.Left >= (block.X + block.Width) || entity.OldLeft < block.X + block.Width) { return(false); } int sectionYPointCount = (int)(entity.Dimensions.Y / tileSize) * 2; float sectionYOffset = tileSize / 2f; for (int i = 0; i < sectionYPointCount; i++) { if (!IsPointColliding(entity.Left, entity.Top + (i * sectionYOffset), block)) { continue; } if (!entity.EmitOnTileCollision(simulation, tc)) { return(true); } entity.Velocity.X = 0; entity.Position.X = entity.OldPosition.X = block.X + tileSize; return(true); } return(false); }
private static bool BottomBorderCollision(Simulation.Simulation simulation, SimulationEntity entity, TileCollision tc) { int tileSize = simulation.World.WorldOptions.WorldScale; // if the object is not moving up if (!(entity.Position.Y - entity.OldPosition.Y < 0)) { return(false); } Rectangle block = tc.TileRectangle(tileSize); if (entity.Top >= (block.Y + block.Height) || entity.OldTop < (block.Y + block.Height)) { return(false); } int sectionXPointCount = (int)(entity.Dimensions.X / tileSize) * 2; float sectionXOffset = tileSize / 2f; for (int i = 0; i <= sectionXPointCount; i++) { if (!IsPointColliding(entity.Left + (i * sectionXOffset), entity.Top, block)) { continue; } if (!entity.EmitOnTileCollision(simulation, tc)) { return(true); } entity.Velocity.Y = -0.001f; entity.Position.Y = entity.OldPosition.Y = block.Y + block.Height; return(true); } return(false); }
public FitnessInfo Evaluate(IBlackBox phenome) { var fitness = 0.0; foreach (var world in worlds) { var lidar = createLidarFor(world.Track); var agent = new NeuralNetworkAgent(lidar, phenome); var simulation = new Simulation.Simulation(agent, world); var simulationResult = simulation.Simulate(simulationStep, perceptionStep, maximumSimulationTime); fitness += fitnessOf(simulationResult); } lock (evaluationLock) { EvaluationCount++; } return(new FitnessInfo( fitness: fitness / worlds.Length, new AuxFitnessInfo[0])); }
/// <summary> /// Updates this entity as part of the chunks in the simulation of this entity /// </summary> /// <param name="simulation"></param> public void Tick(Simulation.Simulation simulation) { TicksSinceCreation++; //Only tick entity once per frame if (simulation.Tick == _currentTick) { return; } //Record last tick _currentTick = simulation.Tick; //Record current position OldPosition = new BfbVector(Position.X, Position.Y); //the future foreach (EntityComponent gameComponent in EntityComponents) { gameComponent?.Update(this, simulation); } MoveEntity(simulation); }
public WorkController(Simulation.Simulation simulation) { _simulation = simulation; }
public SimulationController(Simulation.Simulation simulation, WorkflowProvider workflowProvider) { _simulation = simulation; _workflowProvider = workflowProvider; }
public static void FightPeople(SimulationEntity entity, List <SimulationEntity> targets, Simulation.Simulation simulation) { if (targets.Count <= 0) { return; } ushort damage = entity.Inventory?.GetActiveSlot()?.Configuration?.Damage ?? 0; ushort knockback = entity.Inventory?.GetActiveSlot()?.Configuration?.KnockBack ?? 20; foreach (SimulationEntity target in targets) { if (target.Meta == null || (entity.EntityConfiguration.EntityKey == target.EntityConfiguration.EntityKey)) { continue; } target.Meta.Health -= damage; if (entity.Facing == DirectionFacing.Left) { target.Velocity.Y = -knockback / 2f; target.Velocity.X = -knockback; } else { target.Velocity.Y = -knockback / 2f; target.Velocity.X = knockback; } } }
public RoutingDataModel CreateCurrentSimulationDataModel(Simulation.Simulation simulation, Customer newCustomer, int currentTime) { var flexibleRoutingVehicles = simulation.Context.VehicleFleet.FindAll(v => v.FlexibleRouting); List <Vehicle> dataModelVehicles = new List <Vehicle>(); List <Customer> allExpectedCustomers = new List <Customer>(); foreach (var vehicle in flexibleRoutingVehicles) { dataModelVehicles.Add(vehicle); if (vehicle.TripIterator?.Current != null) { List <Customer> expectedCustomers = new List <Customer>(vehicle.TripIterator.Current.ExpectedCustomers); foreach (var customer in expectedCustomers) { if (!allExpectedCustomers.Contains(customer) && !customer.AlreadyServed) { allExpectedCustomers.Add(customer); } } List <Customer> currentCustomers = vehicle.Customers; foreach (var currentCustomer in currentCustomers) { if (!allExpectedCustomers.Contains(currentCustomer) && !currentCustomer.AlreadyServed) { allExpectedCustomers.Add(currentCustomer); } } //debug foreach (var customer in allExpectedCustomers) { if (customer.IsInVehicle) { var v = simulation.Context.VehicleFleet.Find(veh => veh.Customers.Contains(customer)); //Console.WriteLine(" Customer " + customer.Id + " is already inside vehicle" + v.Id + ": Already visited: " + customer.PickupDelivery[0] +", Need to visit:" + customer.PickupDelivery[1]); } } //end of debug } } if (!allExpectedCustomers.Contains(newCustomer)) { allExpectedCustomers.Add(newCustomer); } //-------------------------------------------------------------------------------------------------------------------------- //Calculation of startDepotArrivalTime, if there is any moving vehicle, otherwise startDepotArrivalTime will be the current event Time var movingVehicles = simulation.Context.VehicleFleet.FindAll(v => !v.IsIdle && v.FlexibleRouting); List <long> startDepotArrivalTimesList = new List <long>(dataModelVehicles.Count); for (int i = 0; i < dataModelVehicles.Count; i++) { startDepotArrivalTimesList.Add(currentTime); //initializes startDepotArrivalTimes with the current event time } if (movingVehicles.Count > 0) //if there is a moving vehicle calculates the baseArrivalTime { foreach (var movingVehicle in movingVehicles) { var vehicleArrivalEvents = simulation.Events.FindAll(e => e is VehicleStopEvent vse && e.Category == 0 && e.Time >= currentTime && vse.Vehicle == movingVehicle); foreach (var arrivalEvent in vehicleArrivalEvents) { if (arrivalEvent is VehicleStopEvent vehicleStopEvent) { if (movingVehicle.CurrentStop != null && movingVehicle.CurrentStop == vehicleStopEvent.Stop) { var currentStartDepotArrivalTime = startDepotArrivalTimesList[dataModelVehicles.IndexOf(movingVehicle)]; startDepotArrivalTimesList[dataModelVehicles.IndexOf(movingVehicle)] = Math.Max(vehicleStopEvent.Time, (int)currentStartDepotArrivalTime); //finds the biggest value between the current baseArrivalTime and the current vehicle's next stop arrival time, and updates its value on the array } } } } } //end of calculation of startDepotsArrivalTime //-------------------------------------------------------------------------------------------------------------------------- var indexManager = new DataModelIndexManager(dataModelVehicles, allExpectedCustomers, startDepotArrivalTimesList); var dataModel = new RoutingDataModel(indexManager, simulation.Params.MaximumRelativeCustomerRideTime, simulation.Params.MaximumAllowedDeliveryDelay); return(dataModel); }
public RoutingDataModel CreateInitialSimulationDataModel(bool allowDropNodes, Simulation.Simulation simulation) { var numberCustomers = simulation.Params.NumberInitialRequests; var numberVehicles = simulation.Params.VehicleNumber; Console.WriteLine(this.ToString() + "Creating new random DataModel for " + numberVehicles + " Vehicles and " + numberCustomers + " Customers, AllowDropNodes: " + allowDropNodes); GenerateNewDataModelLabel: List <Vehicle> dataModelVehicles = new List <Vehicle>(); List <long> startDepotsArrivalTime = new List <long>(numberVehicles); //Creates two available vehicles to be able to perform flexible routing for the pdtwdatamodel for (int i = 0; i < numberVehicles; i++) { var vehicle = new Vehicle(simulation.Params.VehicleSpeed, simulation.Params.VehicleCapacity, simulation.Context.Depot, simulation.Context.Depot); dataModelVehicles.Add(vehicle); startDepotsArrivalTime.Add(0);//startDepotArrival time = 0 for all the vehicles } var customersToBeServed = new List <Customer>(); List <Stop> excludedStops = new List <Stop>(); foreach (var vehicle in dataModelVehicles) { if (!excludedStops.Contains(vehicle.StartStop)) { excludedStops.Add(vehicle.StartStop); } if (!excludedStops.Contains(vehicle.EndStop)) { excludedStops.Add(vehicle.EndStop); } } for (int i = 0; i < numberCustomers; i++) //generate 5 customers with random timeWindows and random pickup and delivery stops { var requestTime = 0; var pickupTimeWindow = new int[] { requestTime, simulation.Params.SimulationTimeWindow[1] }; //the customer pickup time will be between the current request time and the end of simulation time var customer = CustomerFactory.Instance().CreateRandomCustomer(simulation.Context.Stops, excludedStops, requestTime, pickupTimeWindow, false, simulation.Params.VehicleSpeed); //Generates a random static customer customersToBeServed.Add(customer); } var indexManager = new DataModelIndexManager(dataModelVehicles, customersToBeServed, startDepotsArrivalTime); var routingDataModel = new RoutingDataModel(indexManager, simulation.Params.MaximumRelativeCustomerRideTime, simulation.Params.MaximumAllowedDeliveryDelay); var solver = new RoutingSolver(routingDataModel, allowDropNodes); RoutingSearchParameters searchParameters = operations_research_constraint_solver.DefaultRoutingSearchParameters(); searchParameters.LocalSearchMetaheuristic = LocalSearchMetaheuristic.Types.Value.Automatic; searchParameters.SolutionLimit = 1; //until it finds 1 solution var solution = solver.TryGetSolution(searchParameters); if (solution == null) { goto GenerateNewDataModelLabel; } return(routingDataModel); }
public static void Main(string[] args) { var random = new Random(); var circuits = circuitsFilePaths().ToArray(); var perceptionStep = TimeSpan.FromSeconds(0.1); var simulationStep = TimeSpan.FromSeconds(0.05); // 20Hz var maximumSimulationTime = TimeSpan.FromSeconds(60); var tracks = circuits.Select(circuitPath => Track.Load($"{circuitPath}/circuit_definition.json")); var worlds = tracks.Select(track => new StandardWorld(track, simulationStep)).ToArray(); var inputSamplesCount = 3; var maximumScanningDistance = 200; ILidar createLidarFor(ITrack track) => new Lidar(track, inputSamplesCount, Angle.FromDegrees(135), maximumScanningDistance); var settings = new EvolutionSettings { PopulationSize = 1000, SpeciesCount = 30, ElitismProportion = 0, ComplexityThreshold = 50 }; // prepare simulation var parameters = new NeatEvolutionAlgorithmParameters { ElitismProportion = settings.ElitismProportion, SpecieCount = settings.SpeciesCount }; var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = 4 }; var speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOptions); var complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, settings.ComplexityThreshold); var evolutionaryAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>( parameters, speciationStrategy, complexityRegulationStrategy); var phenomeEvaluator = new RaceSimulationEvaluator( random, simulationStep, perceptionStep, maximumSimulationTime, worlds, createLidarFor); var genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme()); var genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>( genomeDecoder, phenomeEvaluator); evolutionaryAlgorithm.Initialize( genomeListEvaluator, genomeFactory: new NeatGenomeFactory( inputNeuronCount: inputSamplesCount, outputNeuronCount: 2, DefaultActivationFunctionLibrary.CreateLibraryNeat(new BipolarSigmoid()), new NeatGenomeParameters { FeedforwardOnly = true, AddNodeMutationProbability = 0.03, DeleteConnectionMutationProbability = 0.05, ConnectionWeightMutationProbability = 0.08, FitnessHistoryLength = 10, }), settings.PopulationSize); var lastVisualization = DateTimeOffset.Now; evolutionaryAlgorithm.UpdateEvent += onUpdate; evolutionaryAlgorithm.StartContinue(); Console.WriteLine("Press enter to stop the evolution."); Console.ReadLine(); Console.WriteLine("Finishing the evolution."); evolutionaryAlgorithm.Stop(); Console.WriteLine("Evolution is stopped."); // simulate best individual Console.WriteLine("Simulating best individual..."); evaluate(evolutionaryAlgorithm.CurrentChampGenome); Console.WriteLine("Done."); void onUpdate(object sender, EventArgs e) { Console.WriteLine($"Generation #{evolutionaryAlgorithm.CurrentGeneration}"); Console.WriteLine($"- max fitness: {evolutionaryAlgorithm.Statistics._maxFitness}"); Console.WriteLine($"- mean fitness: {evolutionaryAlgorithm.Statistics._meanFitness}"); Console.WriteLine(); if (DateTimeOffset.Now - lastVisualization > TimeSpan.FromSeconds(35)) { lastVisualization = DateTimeOffset.Now; Console.WriteLine("Simulating currently best individual..."); evaluate(evolutionaryAlgorithm.CurrentChampGenome); } } void evaluate(NeatGenome genome) { var worldId = random.Next(0, worlds.Length - 1); var world = worlds[worldId]; var bestIndividual = genomeDecoder.Decode(genome); var agent = new NeuralNetworkAgent(createLidarFor(world.Track), bestIndividual); var simulation = new Simulation.Simulation(agent, world); var summary = simulation.Simulate(simulationStep, perceptionStep, maximumSimulationTime); File.Copy($"{circuits[worldId]}/visualization.svg", "C:/Users/simon/Projects/racer-experiment/simulator/src/visualization.svg", overwrite: true); IO.Simulation.StoreResult(world.Track, world.VehicleModel, summary, "", "C:/Users/simon/Projects/racer-experiment/simulator/src/report.json"); } }