public void Settings_CanSet()
{
var sut = CreateSut().Item1;
var settigs = new SimulationSettings();
sut.Settings = settigs;
Assert.Same(settigs, sut.Settings);
}
public void RunDemo(SimulationSettings settings)
{
_chainLinkFactory.SetSettings(settings);
_timerService.SetSettings(settings);
var conveyorData = settings.ConveyorSettingsMpaToAa;
var checkInDisp = _chainLinkFactory.CreateCheckInDispatcher();
var checkIn = _chainLinkFactory.CreateCheckInDesk();
var firstCheckInConnector = _chainLinkFactory.CreateConveyorConnector();
var checkInToPsc = _chainLinkFactory.CreateManyToOneConveyor(conveyorData[0].Length);
var psc = _chainLinkFactory.CreatePsc();
var pscToMpa = _chainLinkFactory.CreateOneToOneConveyor(conveyorData[1].Length);
var mpa = _chainLinkFactory.CreateMpa();
var mpaToAA = _chainLinkFactory.CreateOneToOneConveyor(conveyorData[2].Length);
var aa = _chainLinkFactory.CreateAa();
var bagCollector = _chainLinkFactory.CreateBagCollector();
checkInDisp.SetCheckIns(new List <ICheckInDesk>()
{
checkIn
});
checkIn.AddSuccessor(firstCheckInConnector);
firstCheckInConnector.SetNextNode(checkInToPsc, 0);
checkInToPsc.SetSuccessor(psc);
psc.AddSuccessor(pscToMpa);
pscToMpa.SetSuccessor(mpa);
aa.AddSuccessor(bagCollector);
mpaToAA.SetSuccessor(aa);
mpa.AddSuccessor(mpaToAA);
checkInToPsc.Start();
mpaToAA.Start();
pscToMpa.Start();
_timerService.RunNewTimer();
checkInDisp.Start();
}
public double GetItemMaximumScore(SimulationSettings simSettings)
{
double retVal = double.MinValue;
//retVal = context.Database.SqlQuery<double>(@"
// select
// max(m1 + m2 + m3 + m4 + m5)
// from (
// select
// a.ID,
// iif(@p0 = 0, 0, sum(c.Metric1) * (@p0 / 100)) m1,
// iif(@p1 = 0, 0, sum(c.Metric2) * (@p1 / 100)) m2,
// iif(@p2 = 0, 0, sum(c.Metric3) * (@p2 / 100)) m3,
// iif(@p3 = 0, 0, sum(c.Metric4) * (@p3 / 100)) m4,
// iif(@p4 = 0, 0, sum(c.Metric5) * (@p4 / 100)) m5
// from Items a
// inner join ItemAttributes b on a.ID = b.Item_ID
// inner join Attributes c on b.Attributes_ID = c.ID
// group by a.ID
// ) a
// ", simSettings.Metric1, simSettings.Metric2, simSettings.Metric3, simSettings.Metric4, simSettings.Metric5).FirstOrDefault();
List <double> metricScores = new List <double>();
foreach (var item in items)
{
double metric1 = simSettings.Metric1 == 0 ? 0 : item.Attributes.Select(a => a.Metric1).Sum() * (simSettings.Metric1 / 100);
double metric2 = simSettings.Metric2 == 0 ? 0 : item.Attributes.Select(a => a.Metric2).Sum() * (simSettings.Metric2 / 100);
double metric3 = simSettings.Metric3 == 0 ? 0 : item.Attributes.Select(a => a.Metric3).Sum() * (simSettings.Metric3 / 100);
double metric4 = simSettings.Metric4 == 0 ? 0 : item.Attributes.Select(a => a.Metric4).Sum() * (simSettings.Metric4 / 100);
double metric5 = simSettings.Metric5 == 0 ? 0 : item.Attributes.Select(a => a.Metric5).Sum() * (simSettings.Metric5 / 100);
double metrics = metric1 + metric2 + metric3 + metric4 + metric5;
metricScores.Add(metrics);
}
return(metricScores.Max());
}
public void TestBug38180()
{
var settings = new SimulationSettings()
{
AutoSelect = true,
CompleteWithSpaceOrPunctuation = true,
AutoCompleteEmptyMatch = true,
CompletionData = new [] { "Test", "test" }
};
var listWindow = CreateListWindow(settings);
var list = listWindow.CompletionDataList;
var testCompletionWidget = (TestCompletionWidget)listWindow.CompletionWidget;
SimulateInput(listWindow, "test\t");
Assert.AreEqual("test", testCompletionWidget.CompletedWord);
ContinueSimulation(listWindow, list, ref testCompletionWidget, "t\t");
Assert.AreEqual("test", testCompletionWidget.CompletedWord);
ContinueSimulation(listWindow, list, ref testCompletionWidget, "T\t");
Assert.AreEqual("Test", testCompletionWidget.CompletedWord);
}
public void TestMruSimpleLastItem()
{
var settings = new SimulationSettings()
{
AutoSelect = true,
CompleteWithSpaceOrPunctuation = true,
AutoCompleteEmptyMatch = true,
CompletionData = new[] { "FooBar1", "Bar", "FooFoo2" }
};
var listWindow = CreateListWindow(settings);
var list = listWindow.CompletionDataList;
var testCompletionWidget = (TestCompletionWidget)listWindow.CompletionWidget;
SimulateInput(listWindow, "FooBar\t");
Assert.AreEqual("FooBar1", testCompletionWidget.CompletedWord);
ContinueSimulation(listWindow, list, ref testCompletionWidget, "FooFoo\t");
Assert.AreEqual("FooFoo2", testCompletionWidget.CompletedWord);
ContinueSimulation(listWindow, list, ref testCompletionWidget, "F\t");
Assert.AreEqual("FooFoo2", testCompletionWidget.CompletedWord);
}
private void WaitForStatistics(Simulation simulation, SimulationSettings settings, CancellationToken token)
{
// Change status
simulation.Status = SimulationStatuses.WaitingForStatistics;
// Get statistics in parallel mode
var statistics = new ConcurrentBag <Statistic>();
simulation.ServerNodes.Where(n => n.IsConnected == true).ParallelForEach(node =>
{
var response = _httpService.Get($"{node.HttpAddress}/api/statistic", _nodeTimeout, token);
if (response.IsSuccessStatusCode)
{
var statistic = response.Content.ReadAs <SuccessResponse <Statistic> >();
statistics.Add(statistic.Result);
}
}, token);
// Extract statistics and save them
var scenarioId = simulation.ScenarioId.ToString();
_statisticService.ExtractAndSaveStatistics(statistics.ToList(), settings, scenarioId);
}
private void WaitForNetwork(Simulation simulation, SimulationSettings settings)
{
do
{
// Change status and wait
simulation.Status = SimulationStatuses.WaitingForNetwork;
SpinWait.SpinUntil(() =>
{
var wait = !simulation.ServerNodes.Where(n => n.IsConnected == true).Any(n => n.IsWorking);
if (!wait)
{
wait = HasSimulationTimeElapsed(simulation, settings);
}
return(wait);
});
// Safe wait for network hiccups
Thread.Sleep(TimeSpan.FromSeconds(10));
// If its still working than wait
} while (simulation.ServerNodes.Where(n => n.IsConnected == true).Any(n => n.IsWorking));
}
public void SetSimSettings(SimulationSettings simSettings)
{
if (simSettings != null)
{
this.simSettings = simSettings;
SimType = simSettings.SimType;
Sessions = simSettings.Sessions;
Hours = simSettings.Hours;
Score = simSettings.Score;
chkSimDisplay.IsChecked = simSettings.EnableSimDisplay;
calculateMaxScore();
simScoreSlider.Value = simSettings.DefaultScorePercentage;
simScoreSliderLbl.Content = simScoreSlider.Value + "%";
switch (SimType)
{
case SimulationType.Sessions:
rdbSessions.IsChecked = true;
txtSimInput.Text = Sessions.ToString();
showScoreSlider(false);
break;
case SimulationType.Time:
rdbTime.IsChecked = true;
txtSimInput.Text = Hours.ToString();
showScoreSlider(false);
break;
default:
rdbScore.IsChecked = true;
txtSimInput.Text = Score.ToString();
showScoreSlider(true);
break;
}
}
}
public void ExtractAndSaveStatistics(List <Statistic> statistics, SimulationSettings settings, string scenarioId)
{
var directoryPath = $@"{_directory}\statistics\{scenarioId}\{DateTime.UtcNow:yyyy-MM-dd-hh-mm-ss}";
if (!Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
try
{
SaveSettings(directoryPath, settings);
}
catch (Exception e)
{
Console.WriteLine(e);
}
try
{
CreateExcelFile(directoryPath, statistics, settings);
}
catch (Exception e)
{
Console.WriteLine(e);
}
try
{
CreateBlockchainTrees(statistics, directoryPath);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
protected override void Context()
{
base.Context();
var outputSchemaFactory = IoC.Resolve <IOutputSchemaFactory>();
var solverSettingsFactory = IoC.Resolve <ISolverSettingsFactory>();
var simSettings1 = new SimulationSettings().WithName("Setting");
var simSettings2 = new SimulationSettings().WithName("Setting");
simSettings1.AddChartTemplate(new CurveChartTemplate().WithName("Temp"));
simSettings1.OutputSchema = outputSchemaFactory.CreateDefault();
simSettings1.OutputSelections = new OutputSelections();
simSettings1.OutputSelections.AddOutput(new QuantitySelection("root|comp1|Drug", QuantityType.Drug));
simSettings1.Solver = solverSettingsFactory.CreateCVODE();
simSettings1.Solver.HMin = 1;
simSettings2.AddChartTemplate(new CurveChartTemplate().WithName("Temp"));
simSettings2.OutputSchema = outputSchemaFactory.CreateDefault();
simSettings2.OutputSelections = new OutputSelections();
simSettings2.OutputSelections.AddOutput(new QuantitySelection("root|comp1|Drug", QuantityType.Drug));
simSettings2.Solver = solverSettingsFactory.CreateCVODE();
_object1 = simSettings1;
_object2 = simSettings2;
}
public void TestMruEmptyMatch ()
{
var settings = new SimulationSettings () {
AutoSelect = true,
CompleteWithSpaceOrPunctuation = true,
AutoCompleteEmptyMatch = true,
CompletionData = new[] { "Foo", "Bar", "Test"}
};
var listWindow = CreateListWindow (settings);
var list = listWindow.CompletionDataList;
var testCompletionWidget = (TestCompletionWidget)listWindow.CompletionWidget;
SimulateInput (listWindow, "Foo\t");
ContinueSimulation (listWindow, list, ref testCompletionWidget, "F\t");
Assert.AreEqual ("Foo", testCompletionWidget.CompletedWord);
ContinueSimulation (listWindow, list, ref testCompletionWidget, "Bar\t");
Assert.AreEqual ("Bar", testCompletionWidget.CompletedWord);
ContinueSimulation (listWindow, list, ref testCompletionWidget, "\t");
Assert.AreEqual ("Bar", testCompletionWidget.CompletedWord);
}
public EntityEditorSimulation(SimulationSettings settings, EntityDefinitionDatabase entityDefinitionDatabase) : base(settings, entityDefinitionDatabase)
{
}
public ServerToServerConnectionViewModel(NodeBaseViewModel from, NodeBaseViewModel to, SimulationSettings worldSettings) :
base(from, to)
{
this.worldSettings = worldSettings;
StrokeThickness = 5;
Stroke = Brushes.OrangeRed;
// DispatcherTimer timer = new DispatcherTimer();
// timer.Interval = new TimeSpan(0,0,1);
// timer.Tick += timer_Tick;
// timer.Start();
Type = EdgeLineType.Bezier;
}
https: //www.c-sharpcorner.com/UploadFile/b942f9/implementing-a-double-ended-queue-or-deque-in-C-Sharp/
//c'tors:
public AbstractCellSimulation(SimulationSettings settings)
{
Settings = settings;
stats1 = settings.TrackLifeStats ? new List <decimal>() : null;
}
public void Synchronize_SynchronizationNotPossible_Throws(IReadOnlyList<Ticker> tickers, SimulationSettings settings, string assertFailMessage)
{
Exception otherException = null;
bool thrownArgumentException = false;
try { SyncTickersFactory.Synchronize(tickers, settings); }
catch (ArgumentException) { thrownArgumentException = true; }
catch (Exception ex) { otherException = ex; }
finally
{
Assert.True(thrownArgumentException,
"Expected ArgumentException after calling SyncTickersFactory.Synchronize. Test case: " + assertFailMessage +
(otherException == null ? "" : ". Got different exception: " + otherException.Message.ToString())
);
}
}
public void CanSynchronize_SynchronizationPossible_ReturnsTrue(IReadOnlyList<Ticker> tickers, SimulationSettings settings, string testCase)
{
string error;
Assert.True(SyncTickersFactory.CanSynchronize(tickers, settings, out error));
}
//c'tors:
public BinaryCellSimulation(SimulationSettings settings) : base(settings)
{
ring = new BinaryRingBuffer3D(settings.MemSlots, settings.SizeX, settings.SizeY);
aring = ring;
}
public RaftDiagramDefinition(RaftSoundPlayer raftEventListener, INetworkModel networkModel, SimulationSettings worldSettings)
{
this.raftEventListener = raftEventListener;
this.simulationSettings = worldSettings;
// brokers
AddModelFor <BrokerViewModel, DiagramNodeBroker>(
"Broker",
(p) => new BrokerViewModel(string.Format("Br{0}", brokerNo++))
{
Location = p
},
(vm) => new DiagramNodeBroker()
{
Location = vm.Location, Name = vm.Name
},
(m) => new BrokerViewModel(m.Name)
{
Location = m.Location
}
);
// clients
AddModelFor <ClientViewModel, DiagramNodeClient>(
"NetworkClient",
(p) =>
{
string cliendId = (clientNo++).ToString();
RaftClient raftClient = new RaftClient(networkModel, cliendId);
return(new ClientViewModel(raftClient)
{
Location = p
});
},
(vm) => new DiagramNodeClient()
{
Location = vm.Location, Name = vm.Name
},
(m) =>
{
RaftClient raftClient = new RaftClient(networkModel, m.Name);
return(new ClientViewModel(raftClient)
{
Location = m.Location
});
}
);
// servers
AddModelFor <ServerViewModel, DiagramNodeServer>(
"Server",
(p) =>
{
serverNo++;
string raftNodeId = serverNo.ToString();
RaftHost serverSoftware = new RaftHost(networkModel, raftEventListener, simulationSettings, raftNodeId);
//this looks nasty
return(new ServerViewModel(serverSoftware)
{
Location = p
});
},
(vm) => new DiagramNodeServer()
{
Location = vm.Location, Name = vm.Name
},
(m) =>
{
RaftHost serverSoftware = new RaftHost(networkModel, raftEventListener, simulationSettings, m.Name);
return(new ServerViewModel(serverSoftware)
{
Location = m.Location
});
}
);
}
public void NodeConnectorService_ShouldAttachEndNodes()
{
using (var mock = AutoMock.GetLoose((a) =>
{
a.RegisterType <ChainLinkFactory>().AsImplementedInterfaces();
a.RegisterType <ConveyorConnector>().AsImplementedInterfaces();
}))
{
var factoryMock = new Mock <IChainLinkFactory>();
factoryMock.Setup(f => f.CreateConveyorConnector()).Returns(new Mock <IConveyorConnector>().Object);
var connector = new NodeConnectorService(factoryMock.Object);
var conveyorId = Guid.NewGuid().ToString();
var aaId = Guid.NewGuid().ToString();
var checkInDispatcherMock = new Mock <ICheckInDispatcher>();
var aaDispatcherMock = new Mock <IAADispatcher>();
var bagCollectorMock = new Mock <IBagCollector>();
var conveyorMock = new Mock <IOneToOneConveyor>();
conveyorMock.Setup(m => m.NodeId).Returns(conveyorId);
var aaMock = new Mock <IAa>();
aaMock.Setup(m => m.NodeId).Returns(aaId);
aaMock.Setup(m => m.AddSuccessor(bagCollectorMock.Object));
var aa = new NodeCreationData()
{
Id = aaId,
NextNodes = null,
Type = BuildingComponentType.AA
};
var conveyor = new NodeCreationData()
{
Id = conveyorId,
NextNodes = new Dictionary <NodeCreationData, int?>()
{
{ aa, 0 }
},
Type = BuildingComponentType.Conveyor
};
var simulationSettings = new SimulationSettings()
{
Nodes = new List <NodeCreationData>()
{
aa, conveyor
}
};
var nodes = new List <IChainLink>()
{
bagCollectorMock.Object,
aaDispatcherMock.Object,
checkInDispatcherMock.Object,
conveyorMock.Object,
aaMock.Object
};
connector.ConnectNodes(nodes, simulationSettings.Nodes);
aaMock.Verify(m => m.AddSuccessor(bagCollectorMock.Object), Times.Once);
}
}
private IEnumerator SimulateGeneration()
{
var solutions = new Solution[Settings.PopulationSize];
var solutionIndex = 0;
// Prepare batch simulation
int actualBatchSize = Settings.SimulateInBatches ? Settings.BatchSize : Settings.PopulationSize;
int numberOfBatches = (int)Math.Ceiling((double)this.Settings.PopulationSize / actualBatchSize);
int firstChromosomeIndex = 0;
// Cache values that can be changed during the simulation
this.cachedSettings = this.Settings;
if (NewGenerationDidBegin != null)
{
NewGenerationDidBegin();
}
for (int i = 0; i < numberOfBatches; i++)
{
this.currentBatchNumber = i + 1;
int remainingCreatures = Settings.PopulationSize - (i * actualBatchSize);
int currentBatchSize = Math.Min(actualBatchSize, remainingCreatures);
var sceneLoadConfig = new SceneController.SimulationSceneLoadConfig(
this.SimulationData.CreatureDesign,
currentBatchSize,
this.SimulationData.SceneDescription,
SceneController.SimulationSceneType.Simulation,
GetLegacySimulationOptions()
);
var context = new SceneController.SimulationSceneLoadContext();
var sceneContext = new SimulationSceneContext(this.SimulationData);
yield return(SceneController.LoadSimulationScene(sceneLoadConfig, context, sceneContext));
this.batchPhysicsScene = context.PhysicsScene;
var batch = context.Creatures;
this.currentCreatureBatch = batch;
var chromosomeCount = Math.Min(this.SimulationData.CurrentChromosomes.Length, batch.Length);
var chromosomes = new float[chromosomeCount][];
for (int c = 0; c < chromosomeCount; c++)
{
chromosomes[c] = this.SimulationData.CurrentChromosomes[c + firstChromosomeIndex];
}
firstChromosomeIndex += batch.Length;
ApplyBrains(batch, chromosomes);
yield return(SimulateBatch());
// Evaluate creatures and destroy the scene after extracting all
// required performance statistics
for (int j = 0; j < batch.Length; j++)
{
var creature = batch[j];
solutions[solutionIndex++] = new Solution()
{
Encodable = creature.brain.Network,
Stats = creature.GetStatistics(this.cachedSettings.SimulationTime)
};
}
yield return(SceneManager.UnloadSceneAsync(context.Scene));
}
EvaluateSolutions(solutions);
}
public void SetSettings(SimulationSettings settings)
{
this._simulationSettings = settings;
}
public void CanSynchronize_WrongTestCase_ReturnsFalse(IReadOnlyList<Ticker> tickers, SimulationSettings settings, string assertFailMessage)
{
string error;
Assert.False(SyncTickersFactory.CanSynchronize(tickers, settings, out error));
}
private void fillControls()
{
#region Game-Settings
// Limits
roundsNumericUpDown.Minimum = SimulatorConfiguration.ROUNDSMIN;
roundsNumericUpDown.Maximum = SimulatorConfiguration.ROUNDSMAX;
loopsNumericUpDown.Minimum = SimulatorConfiguration.LOOPSMIN;
loopsNumericUpDown.Maximum = SimulatorConfiguration.LOOPSMAX;
// Values
roundsNumericUpDown.Value = setup.SimulatorConfiguration.RoundCount;
loopsNumericUpDown.Value = setup.SimulatorConfiguration.LoopCount;
int initValue = Math.Abs(setup.SimulatorConfiguration.MapInitialValue);
mapInitCheckBox.Checked = (initValue != 0);
check_mapInit(null, null);
mapGeneratorMaskedTextBox.Text = initValue.ToString("000000000");
#endregion
#region Debug and Timeouts
// Limits
loopTimeoutNumericUpDown.Minimum = SimulatorConfiguration.LOOPTIMEOUTMIN;
loopTimeoutNumericUpDown.Maximum = int.MaxValue;
roundTimeoutNumericUpDown.Minimum = SimulatorConfiguration.ROUNDTIMEOUTMIN;
roundTimeoutNumericUpDown.Maximum = int.MaxValue;
// Values
debugInfoCheckBox.Checked = setup.SimulatorConfiguration.AllowDebuginformation;
check_timeouts(null, null);
ignoreTimeoutsCheckBox.Checked = setup.SimulatorConfiguration.IgnoreTimeouts;
loopTimeoutNumericUpDown.Value = setup.SimulatorConfiguration.LoopTimeout;
roundTimeoutNumericUpDown.Value = setup.SimulatorConfiguration.RoundTimeout;
#endregion
#region Security
// Values
allowIoCheckBox.Checked = setup.SimulatorConfiguration.AllowFileAccess;
allowDbCheckBox.Checked = setup.SimulatorConfiguration.AllowDatabaseAccess;
allowUiCheckBox.Checked = setup.SimulatorConfiguration.AllowUserinterfaceAccess;
allowRefCheckBox.Checked = setup.SimulatorConfiguration.AllowReferences;
allowNetworkCheckBox.Checked = setup.SimulatorConfiguration.AllowNetworkAccess;
#endregion
#region Core-Settings
// Set Default
presetComboBox.Items.Add(SimulationSettings.Default);
// Other Presets
using (var stream = new MemoryStream(Presets.CaptureTheApple))
presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream));
using (var stream = new MemoryStream(Presets.Debugging))
presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream));
using (var stream = new MemoryStream(Presets.Heros))
presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream));
using (var stream = new MemoryStream(Presets.SugarRun))
presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream));
using (var stream = new MemoryStream(Presets.SurvivalOfTheFittest))
presetComboBox.Items.Add(SimulationSettings.LoadSettings(stream));
// Enumerate all known settingsfiles and add them to the combobox
List <string> lostSettingsFiles = new List <string>();
foreach (string knownSettingFile in setup.KnownSettingFiles)
{
try
{
SimulationSettings settings = SimulationSettings.LoadSettings(knownSettingFile);
presetComboBox.Items.Add(settings);
}
catch (Exception)
{
// TODO: Lokalisieren
MessageBox.Show("Fehler beim Laden der Settings-Datei " + knownSettingFile + ". Diese Datei wird aus der Liste der bekannten Settings entfernt.");
lostSettingsFiles.Add(knownSettingFile);
}
}
// Remove all lost settingsfiles
foreach (string lostSettingsFile in lostSettingsFiles)
{
setup.KnownSettingFiles.Remove(lostSettingsFile);
}
// Preselect current settings
presetComboBox.SelectedItem = setup.SimulatorConfiguration.Settings;
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="Simulation"/> class.
/// </summary>
public Simulation()
{
Settings = new SimulationSettings();
var collisionDetection = new CollisionDetection
{
CollisionFilter = new CollisionFilter(),
FullContactSetPerFrame = true
};
CollisionDomain = new CollisionDomain(collisionDetection);
ConstraintSolver = new SequentialImpulseBasedSolver(this);
Constraints = new ConstraintCollection();
Constraints.CollectionChanged += OnConstraintsChanged;
ForceEffects = new ForceEffectCollection();
ForceEffects.CollectionChanged += OnForceEffectsChanged;
RigidBodies = new RigidBodyCollection();
RigidBodies.CollectionChanged += OnRigidBodiesChanged;
ContactConstraintsInternal = new List<ContactConstraint>();
IslandManager = new SimulationIslandManager(this);
// Define the "World" as a rigid body.
// - World is an imaginary body that is used to define the space of the simulation.
// - The user can use World in constraints e.g. to anchor objects in the world.
// - No contacts are computed for World.
World = new RigidBody(new BoxShape(20000, 20000, 20000))
{
CollisionResponseEnabled = false,
CollisionObject = { Type = CollisionObjectType.Trigger },
MotionType = MotionType.Static,
Name = "World",
Simulation = this,
};
// Remove "World" from the collision domain.
CollisionDomain.CollisionObjects.Remove(World.CollisionObject);
Diagnostics = new SimulationDiagnostics();
// Store delegate methods to avoid garbage when multithreading.
_updateVelocityMethod = i =>
{
var body = RigidBodies[i];
body.UpdateVelocity(_fixedTimeStep);
};
_solveIslandMethod = SolveIsland;
_updatePoseMethod = i =>
{
var body = RigidBodies[i];
body.UpdatePose(_fixedTimeStep);
};
_computeTimeOfImpactMethod = ComputeTimeOfImpact_Multithreaded;
_moveToTimeOfImpactMethod = MoveToTimeOfImpact;
}
public void Synchronize_DescriptionsAreCorrect(IReadOnlyList<Ticker> tickers, SimulationSettings settings, SyncTickers expected, string testCase)
{
var sut = SyncTickersFactory.Synchronize(tickers, settings);
Assert.True(expected.Descriptions.SequenceEqual(sut.Descriptions, new TickerDescriptionTests.TickerDescriptionComparer()),
"Ticker descriptions are not correct.");
}
/// <summary>
/// Loads the simulation from save file of format version 1.
/// </summary>
/// <param name="name">The name of the simualtion save.</param>
/// <param name="content">The Content of the save file.</param>
public static SimulationData ParseSimulationData(string name, string content, LegacySimulationLoader.SplitOptions splitOptions)
{
var creatureName = name.Split('-')[0].Replace(" ", "");
if (string.IsNullOrEmpty(creatureName))
{
creatureName = "Unnamed";
}
var components = content.Split(splitOptions.SPLIT_ARRAY, System.StringSplitOptions.None);
// extract the save data from the file contents.
var objectiveType = ObjectiveUtil.ObjectiveForNumber(int.Parse(components[0].Replace(Environment.NewLine, "")));
var timePerGen = int.Parse(components[1].Replace(Environment.NewLine, ""));
var creatureData = components[2];
var creatureDesign = CreatureSerializer.ParseCreatureDesign(creatureData, creatureName);
var bestChromosomesData = new List <string>(components[3].Split(splitOptions.NEWLINE_SPLIT, StringSplitOptions.None));
var bestChromosomes = new List <ChromosomeData>();
foreach (var chromosomeData in bestChromosomesData)
{
if (chromosomeData != "")
{
// Parse the chromosome data
var parts = chromosomeData.Split(':');
var chromosome = parts[0];
var fitness = float.Parse(parts[1]);
var chromosomeStats = new ChromosomeStats(chromosome, new CreatureStats());
chromosomeStats.stats.fitness = fitness;
var data = new StringChromosomeData(chromosome, chromosomeStats.stats);
bestChromosomes.Add(data.ToChromosomeData());
}
}
var chromosomeComponents = components[4].Split(splitOptions.NEWLINE_SPLIT, StringSplitOptions.None);
var currentChromosomes = new List <float[]>();
foreach (var chromosome in chromosomeComponents)
{
if (chromosome != "")
{
currentChromosomes.Add(ConversionUtils.BinaryStringToFloatArray(chromosome));
}
}
var currentGeneration = bestChromosomes.Count + 1;
var settings = new SimulationSettings();
settings.Objective = objectiveType;
settings.SimulationTime = timePerGen;
settings.PopulationSize = currentChromosomes.Count;
var networkSettings = NeuralNetworkSettings.Default;
var sceneDescription = DefaultSimulationScenes.DefaultSceneForObjective(settings.Objective);
sceneDescription.PhysicsConfiguration = ScenePhysicsConfiguration.Legacy;
int lastSimulatedV2Generation = bestChromosomes.Count;
return(new SimulationData(
settings, networkSettings, creatureDesign,
sceneDescription, bestChromosomes,
currentChromosomes.ToArray(),
lastSimulatedV2Generation
));
}
public static void Run()
{
try
{
int numScreens = Screen.AllScreens.Length;
if (numScreens != 1 && numScreens != 2)
{
throw new NotImplementedException("Only supports single and dual monitor setup!");
}
SimulationSettings simSettings = SimulatorResources.GetSimulationSettings();
if (simSettings.RenderMode == RenderModes.Stereo && numScreens < 2)
{
Console.WriteLine(@"Could not run stereo mode. Can't find two monitors connected?");
simSettings.RenderMode = RenderModes.Normal;
}
IntPtr rightEyeWindow = IntPtr.Zero;
if (simSettings.RenderMode == RenderModes.Stereo)
{
rightEyeWindow = SpawnRightEyeWindow();
}
// Start the simulator game entry point
using (var game = new SimulatorGame(simSettings, rightEyeWindow))
{
// Make sure the XNA game window (left eye) displays as a full screen window
// just as the one we just created for the right eye
var gameForm = (Form)System.Windows.Forms.Control.FromHandle(game.Window.Handle);
gameForm.FormBorderStyle = FormBorderStyle.None;
gameForm.LostFocus += (sender, e) => game.IsCapturingMouse = false;
gameForm.GotFocus += (sender, e) => Game_GotFocus(game);
gameForm.MouseClick += (sender, e) =>
{
if (e.Button == MouseButtons.Right)
{
Game_MouseRightClick(game);
}
};
// Name the window according to mode
gameForm.Text = (simSettings.RenderMode == RenderModes.Stereo)
? "A²DS Stereoscopy (left eye)"
: "A²DS";
_settingsController = new SettingsController(gameForm);
// Hook the settings controller to the simulator by events, so changes in PID settings causes
// autopilot to use new PID settings.
_settingsController.PIDSettingsChanged +=
() => game.SetPIDSetup(_settingsController.CurrentPIDSetup);
// Run the game code
game.Run();
}
}
catch (Exception e)
{
string msg = "Error occured!\n\n" + e;
Console.WriteLine(e);
MessageBox.Show(msg);
}
}
public void SimulationSettings_Clone_ClonesRememberedChilds()
{
var container = new SimulationSettings();
var setting = container.Get<CloseAllOnLastBarSetting>();
setting.Value = !setting.Value;
var sut = (container.Clone() as SimulationSettings);
Assert.Equal<bool>(setting.Value, sut.Get<CloseAllOnLastBarSetting>().Value);
}
public void InjectSettings(SimulationSettings s)
{
settings = s;
}
public void SimulationSettings_Clone_InvokesCloneOnChilds(Type settingType)
{
var container = new SimulationSettings();
MethodInfo getMethod = typeof(SimulationSettings).GetMethod("Get");
MethodInfo genericGetMethod = getMethod.MakeGenericMethod(settingType);
object fromGetOnOriginal = genericGetMethod.Invoke(container, null);
var sut = (container.Clone() as SimulationSettings);
object fromGetOnClone = genericGetMethod.Invoke(sut, null);
Assert.NotSame(fromGetOnOriginal, fromGetOnClone);
}
public void Synchronize_ObservationsAreCorrect(IReadOnlyList<Ticker> tickers, SimulationSettings settings, SyncTickers expected, string testCase)
{
Func<IEnumerable<Observation>, string> printer = x => x.Select((o, iO) => string.Format("[{0}: ({2}) {1}]", iO, o.Date,
o.CurrentQuoteCount.Select(i => i.ToString()).Aggregate((s1, s2) => s1 + "," + s2))).Aggregate((s1, s2) => s1 + "," + s2);
var sut = SyncTickersFactory.Synchronize(tickers, settings);
Assert.True(expected.SequenceEqual(sut, new ObservationTests.ObservationComparer()),
"Observation are not correct."+
" Expected: "+printer(expected)+
". Got: "+printer(sut));
}
public void AddChartTemplate(CurveChartTemplate chartTemplate)
{
SimulationSettings.AddChartTemplate(chartTemplate);
}
//c'tors:
public GenericCellSimulation(SimulationSettings settings) : base(settings)
{
ring = new GenericRingBuffer3D <C>(settings.MemSlots, settings.SizeX, settings.SizeY);
aring = ring;
}
public void Synchronize_TickersAreCorrect(IReadOnlyList<Ticker> tickers, SimulationSettings settings, SyncTickers expected, string testCase)
{
var sut = SyncTickersFactory.Synchronize(tickers, settings);
Assert.True(expected.SimplifiedTickers.SequenceEqual(sut.SimplifiedTickers, new SimplifiedTickerTests.SimplifiedTickerComparer()),
"Simplified tickers are not correct.");
}
public ClientToServerConnectionViewModel(NodeBaseViewModel from, NodeBaseViewModel to, SimulationSettings worldSettings) :
base(from, to)
{
StrokeThickness = 2;
this.worldSettings = worldSettings;
}
protected override void Context()
{
sut = new SimulationSettings();
}
public SimulationProject()
{
Graph = new Graph.Graph();
SimulationSettings = SimulationSettings.Default;
}
public CurveChartTemplate ChartTemplateByName(string templateName)
{
return(SimulationSettings.ChartTemplateByName(templateName));
}
static string RunSimulation(SimulationSettings settings)
{
CompletionListWindow listWindow = CreateListWindow (settings);
SimulateInput (listWindow, settings.SimulatedInput);
return ((TestCompletionWidget)listWindow.CompletionWidget).CompletedWord;
}
public void RemoveAllChartTemplates()
{
SimulationSettings.RemoveAllChartTemplates();
}
public void SimulationSettings_Get_CanInitializeAllSettings(Type settingType)
{
var sut = new SimulationSettings();
MethodInfo getMethod = typeof(SimulationSettings).GetMethod("Get");
MethodInfo genericGetMethod = getMethod.MakeGenericMethod(settingType);
Assert.NotNull(genericGetMethod.Invoke(sut, null));
}
public void CanSynchronize_WrongTestCase_SetsNotEmptyError(IReadOnlyList<Ticker> tickers, SimulationSettings settings, string assertFailMessage)
{
string error;
SyncTickersFactory.CanSynchronize(tickers, settings, out error);
Assert.False(string.IsNullOrEmpty(error), "Error string is empty but should contain explanation message.");
}
public void RemoveChartTemplate(string chartTemplateName)
{
SimulationSettings.RemoveChartTemplate(chartTemplateName);
}
public void SimulationSettings_Get_RemembersCreatedObject(Type settingType)
{
var sut = new SimulationSettings();
MethodInfo getMethod = typeof(SimulationSettings).GetMethod("Get");
MethodInfo genericGetMethod = getMethod.MakeGenericMethod(settingType);
object fromFirstGet = genericGetMethod.Invoke(sut, null);
object fromSecondGet = genericGetMethod.Invoke(sut, null);
Assert.Same(fromFirstGet, fromSecondGet);
}
