Exemple #1
0
            public static CompletedSimulation ChooseWorst(CompletedSimulation first, CompletedSimulation second)
            {
                if (first == null)
                {
                    return(second);
                }
                if (second == null)
                {
                    return(first);
                }
                if (first.HasError)
                {
                    return(first);
                }
                if (second.HasError)
                {
                    return(second);
                }

                if (first.Stats.SamplesTransmitted <= second.Stats.SamplesTransmitted)
                {
                    return(first);
                }

                return(second);
            }
        internal async Task <(Dictionary <IAiFactory, (Double meanMoves, Double meanPower, Double meanSamples, Double sampleStdDev)> aggregates, CompletedSimulation worstSim, IAiFactory worstAi)> Simulate(IList <IAiFactory> aiFactories, Int32 runCount)
        {
            var aggregates = new Dictionary <IAiFactory, (Double meanMoves, Double meanPower, Double meanSamples, Double sampleStdDev)>();
            CompletedSimulation worstSim = null;
            IAiFactory          worstAi  = null;
            Int32 levelSeed = Rando.Next(Int32.MinValue, Int32.MaxValue);

            foreach (var aiFactory in aiFactories)
            {
                var levelRand             = new Random(levelSeed);
                var levelGeneratorFactory = new OpenCheckingGeneratorFactory(new DefaultLevelGeneratorFactory(), 6);
                var roverFactory          = new DefaultRoverFactory();
                var simulator             = new Simulator(levelGeneratorFactory, roverFactory, aiFactory);

                using (Completer completer = Completer.Create(Path.Combine(OutputDirectory, $"RoverSim-{aiFactory.Name}.csv")))
                {
                    await simulator.SimulateAsync(runCount, completer.Consume);

                    aggregates[aiFactory] = completer.GetAggregates();
                    worstSim = Completer.ChooseWorst(worstSim, completer.WorstSim);
                    if (worstSim == completer.WorstSim)
                    {
                        worstAi = aiFactory;
                    }
                }
            }

            return(aggregates, worstSim, worstAi);
        }
Exemple #3
0
            public void Consume(CompletedSimulation sim)
            {
                RoverStats stats = sim.Stats;

                // Write CSV
                _csv.WriteField(stats.MovesLeft.ToString());
                _csv.WriteField(stats.Power.ToString());
                _csv.WriteField(stats.SamplesCollected.ToString());
                _csv.WriteField(stats.SamplesProcessed.ToString());
                _csv.WriteField(stats.SamplesTransmitted.ToString());
                _csv.WriteField(stats.MoveCount.ToString());
                _csv.WriteField(stats.MoveCallCount.ToString());
                _csv.WriteField(stats.CollectPowerCallCount.ToString());
                _csv.WriteField(stats.CollectSampleCallCount.ToString());
                _csv.WriteField(stats.ProcessSamplesCallCount.ToString());
                _csv.WriteField(stats.TransmitCallCount.ToString());
                _csv.WriteField(sim.ProtoLevel.Seed);
                _csv.NextRecord();

                // Update stats
                _moves += stats.MovesLeft;
                _power += stats.Power;

                _count++;
                Double delta = stats.SamplesTransmitted - _meanSamples;

                _meanSamples += delta / _count;
                Double delta2 = stats.SamplesTransmitted - _meanSamples;

                _mean2Samples += delta * delta2;

                // Update Worst Sim
                WorstSim = ChooseWorst(WorstSim, sim);
                _progress.Report(1);
            }
Exemple #4
0
 public RenderViewModel(IAiFactory ai, CompletedSimulation simulation)
 {
     Ai         = ai ?? throw new ArgumentNullException(nameof(ai));
     Simulation = simulation ?? throw new ArgumentNullException(nameof(simulation));
     Tiles      = Simulation.OriginalLevel.AsMutable().Terrain;
     RoverX     = Simulation.Parameters.InitialPosition.X;
     RoverY     = Simulation.Parameters.InitialPosition.Y;
 }
Exemple #5
0
 public RenderForm(CompletedSimulation demoResult, IAiFactory demoAi)
 {
     DemoResult      = demoResult ?? throw new ArgumentNullException(nameof(demoResult));
     DemoAi          = demoAi ?? throw new ArgumentNullException(nameof(demoAi));
     OutputDirectory = Path.Combine(Directory.GetCurrentDirectory(), DemoAi.Name);
     InitializeComponent();
     RenderControl.VisibleState = VisibleState.GenerateBlank(DemoResult.Parameters);
 }
Exemple #6
0
        private static void ExportFrames(CompletedSimulation sim, IAiFactory aiFactory, String outputDir)
        {
            const Int32 tileSize = 10;

            IAi          ai    = aiFactory.Create(sim.Parameters);
            Level        level = sim.ProtoLevel.Generate();
            Rover        rover = new Rover(level, sim.Parameters);
            VisibleState state = VisibleState.GenerateBlank(level.BottomRight, rover.Position);

            using var actionEnumerator = ai.Simulate(rover.Accessor).GetEnumerator();

            Int32 maxFrameCount  = sim.Parameters.InitialMovesLeft;
            Int32 filenameDigits = (Int32)Math.Ceiling(Math.Log10(maxFrameCount)) + 1;

            String        fileBase = Path.Combine(outputDir, $"frame-{sim.ProtoLevel.Seed}-");
            DirectoryInfo dir      = new DirectoryInfo(outputDir);

            if (dir.Exists)
            {
                foreach (var file in dir.EnumerateFiles())
                {
                    file.Delete();
                }
            }
            else
            {
                dir.Create();
            }

            Int32 width  = level.Width * tileSize;
            Int32 height = level.Height * tileSize;

            using Bitmap bitmap    = new Bitmap(width, height);
            using Graphics surface = Graphics.FromImage(bitmap);

            Update update     = new Update(terrain: rover.Adjacent);
            Int32  frameIndex = 0;

            do
            {
                if (!state.Apply(update))
                {
                    continue;
                }

                GdiRenderer.Draw(surface, width, height, state);
                String suffix   = frameIndex.ToString().PadLeft(filenameDigits, '0');
                String filename = fileBase + suffix + ".png";
                bitmap.Save(filename, System.Drawing.Imaging.ImageFormat.Png);
                frameIndex++;
            }while (actionEnumerator.MoveNext() && rover.Perform(actionEnumerator.Current, out update));
        }
Exemple #7
0
        private async void SimulateButton_Click(object sender, EventArgs e)
        {
            if (!running)
            {
                running = true;
            }
            else
            {
                return;
            }

            if (!Int32.TryParse(RunCount.Text, out Int32 runCount))
            {
                return;
            }

            WorkManager manager = new WorkManager();

            List <IAiFactory> selectedAis = aiFactories.Where(t => AiList.SelectedItems.ContainsKey(t.Name)).ToList();

            TimeUsed.Text = "Working...";
            var stopwatch = Stopwatch.StartNew();

            (var results, var worstSim, var worstAi) = await manager.Simulate(selectedAis, runCount);

            stopwatch.Stop();
            TimeUsed.Text = stopwatch.Elapsed.TotalSeconds.ToString();

            _renderSim       = worstSim;
            _renderAiFactory = worstAi;
            if (_renderSim != null && _renderSim.HasError)
            {
                MessageBox.Show("ERROR");
            }

            foreach (var aiFactory in results.Keys)
            {
                var stat = results[aiFactory];
                if (Results.Rows.Count == 0)
                {
                    DataGridViewRow row = new DataGridViewRow();
                    Results.Rows.Add(row);
                }

                (var meanMoves, var meanPower, var meanSamples, var sampleStdDev) = stat;
                Results.Rows[0].SetValues(aiFactory.Name, meanMoves.ToString("F2"), meanPower.ToString("F2"), meanSamples.ToString("F2"), sampleStdDev.ToString("F2"));
            }
            running = false;
        }
Exemple #8
0
        public RenderViewModel(IAiFactory aiFactory, CompletedSimulation simulation)
        {
            Ai         = aiFactory ?? throw new ArgumentNullException(nameof(aiFactory));
            Simulation = simulation ?? throw new ArgumentNullException(nameof(simulation));

            Start = ReactiveCommand.CreateFromObservable(() =>
            {
                IAi ai      = Ai.Create(Simulation.Parameters);
                Level level = Simulation.ProtoLevel.Generate();
                Rover rover = new Rover(level, Simulation.Parameters);

                return(Observable.Create <(RoverAction action, Update update)>(obs =>
                {
                    return Task.Run(async() =>
                    {
                        var actionEnumerator = ai.Simulate(rover.Accessor).GetEnumerator();
                        while (actionEnumerator.MoveNext() && rover.Perform(actionEnumerator.Current, out Update update))
                        {
                            obs.OnNext((actionEnumerator.Current, update));
                            Int32 delay = actionEnumerator.Current.Instruction switch
                            {
                                Instruction.Move => 75,
                                Instruction.CollectSample => 50,
                                _ => 0
                            };
                            if (delay != 0)
                            {
                                await Task.Delay(delay);
                            }
                        }
                    });
                }));
            });

            Stats = Start.Aggregate(RoverStats.Create(Simulation.Parameters), (s, update) => s.Add(update.action, update.update));

            State = this
                    .WhenAnyObservable(m => m.Start)
                    .Select(update => update.update)
                    .Scan(VisibleState.GenerateBlank(Simulation.Parameters), (state, update) =>
            {
                state.Apply(update);
                return(state);
            });
        }
Exemple #9
0
 public RenderForm(CompletedSimulation demoResult, IAiFactory demoAi)
 {
     DemoResult = demoResult ?? throw new ArgumentNullException(nameof(demoResult));
     DemoAi = demoAi ?? throw new ArgumentNullException(nameof(demoAi));
     InitializeComponent();
 }
Exemple #10
0
 public SimulationRowViewModel(IAiFactory ai, CompletedSimulation simulation)
 {
     Ai         = ai ?? throw new ArgumentNullException(nameof(ai));
     Simulation = simulation ?? throw new ArgumentNullException(nameof(simulation));
 }