public object Execute(object sender, object parameter)
{
if (Track == null && parameter == null)
{
return(null);
}
IAudioTrack track = null;
if (Track == null)
{
if (InputConverter != null)
{
track = (IAudioTrack)InputConverter.Convert(parameter, null, null, null);
}
else
{
track = (IAudioTrack)parameter;
}
}
else
{
track = Track;
}
Messenger.Default.Send(new PlayTrackMessage {
Tracks = (IEnumerable <IAudioTrack>)TracksList, TrackToPlay = track
});
NavigationHelper.Navigate(AppViews.PlayerView);
return(null);
}
public void ShouldConvertAlleLettersToAppropriateValues()
{
var input = Helpers.GenerateAllLetters();
var output = InputConverter.Convert(input);
Assert.AreEqual(Helpers.GenerateAllNumberValuesForLetters(), output);
}
public void ShouldConvertUpperCaseAToAppropriateValue()
{
const string input = "A";
var output = InputConverter.Convert(input);
Assert.AreEqual(new[] { 27 }, output);
}
public static void then_should_print_out_floating_map_of_a_for_input_1a()
{
// Arrange
const string inputString = "1a";
var outputDevice = new StringOutputDevice();
var inputConverter = new InputConverter(outputDevice, inputString);
// Act
inputConverter.Convert();
// Assert
Assert.That(outputDevice.Output, Is.EqualTo(" +"));
}
public static void then_should_print_out_the_map_for_i()
{
// Arrange
const string inputString = "i";
var outputDevice = new StringOutputDevice();
var inputConverter = new InputConverter(outputDevice, inputString);
// Act
inputConverter.Convert();
// Assert
Assert.That(outputDevice.Output, Is.EqualTo("++--***.."));
}
public static void then_should_convert_complex_string_to_full_map()
{
// Arrange
const string inputString = "j3f3e3e3d3d3c3cee3c3c3d3d3e3e3f3fjij3f3f3e3e3d3d3c3cee3c3c3d3d3e3e3fj";
var outputDevice = new Mock <IOutputDevice>();
var inputConverter = new InputConverter(outputDevice.Object, inputString);
// Act
inputConverter.Convert();
// Assert
outputDevice.Verify(device => device.Write("++--***..."));
outputDevice.Verify(device => device.Write(" ++--** "));
}
public static int Main(string[] args)
{
InputConverterFactory inputConverterFactory = new InputConverterFactory();
InputConverter inputConverter = inputConverterFactory.ComposeInputConverter();
Attempt <string> attempt = inputConverter.Convert(args);
if (attempt.Failed)
{
Console.WriteLine(attempt.Error.Message);
return(1);
}
Console.WriteLine(attempt.Result);
return(0);
}
public void CanConvertThree()
{
Attempt <string> inRoman = _inputConverter.Convert(new[] { "3" });
Assert.AreEqual("III", inRoman.Result);
}
public void ShouldThrowErrorForInvalidInput()
{
const string input = "-";
Assert.Throws <ArgumentException>(() => InputConverter.Convert(input));
}
internal void Work()
{
try
{
//prepare
CurrentPosition = new GWPosition <PositionData, ActionData>(InputConverter.Convert(Input), 0, null);
//CurrentPositions.AddLast(CurrentPosition);
var isnewPosition = true;
while (CurrentPosition != null && DateTime.Now - StartTime < ComputationTime)
{
NodesVisited++;
//foreach (var position in CurrentPositions)
{
//gather options:
var options = new LinkedList <GWAction <PositionData, ActionData> >();
if (CurrentPosition.HasInitActions)
{
//options.AddRange(CurrentPosition.UndiscoveredActions);
}
else
{
foreach (var actionFinder in ActionFinders)
{
var foundOptions = actionFinder.FindActions(CurrentPosition);
options.AddRange(foundOptions);
//TODO: filter double actions (from several actionFinders)
}
if (options.NullOrEmpty())
{
//discovery of ending position
EndPositionDiscovered(CurrentPosition);
}
else
{
foreach (var actionEvaluator in ActionEvaluators)
{
actionEvaluator.Weight = Program.Random.NextDouble();
}
int tempNr = 0;
foreach (var option in options)
{
option.TempNumber = tempNr;
tempNr++;
}
//evaluateOptions
int EachEvaluatorOptions = 5;
//int Branches = 50;
var optionsScore = new double[options.Count];
foreach (var actionEvaluator in ActionEvaluators)
{
var bestOptions = new LinkedList <GWAction <PositionData, ActionData> >();
foreach (var option in options)
{
option.Score = actionEvaluator.Evaluate(option) * actionEvaluator.Weight;
bestOptions.SortedInsert(option, EachEvaluatorOptions, o => o.Score);
}
var bestOptionsList = bestOptions.ToList();
for (int i = 0; i < bestOptionsList.Count; i++)
{
optionsScore[bestOptionsList[i].TempNumber] += (EachEvaluatorOptions - i) * actionEvaluator.Weight;
}
}
foreach (var option in options)
{
option.Score = optionsScore[option.TempNumber];
}
//CurrentPosition.AddActions(options.MaxEntries(o => o.Score, Branches));
}
}
if (options.NullOrEmpty())
{
//this position is fully discovered
BranchingPointsControlUnit.RemoveBranchingPoint(CurrentPosition);
CurrentPosition = BranchingPointsControlUnit.GetNextBranchingPoint();
isnewPosition = false;
}
else
{
if (isnewPosition)
{
BranchingPointsControlUnit.AddBranchingPoint(CurrentPosition);
}
var bestOption = options.MaxEntry(op => op.Score);
//execute best Option
//var bestOption = ordered_options.First();
var newPosition = ActionExecuter.CreateNewPosition(bestOption);
foreach (var evaluator in PositionEvaluators)
{
newPosition.Score += evaluator.Evaluate(newPosition);
}
//newPosition.Parents.AddLast(CurrentPosition);
//CurrentPosition.Children.AddLast(newPosition);
//CurrentPosition.UndiscoveredActions.Remove(bestOption);
//CurrentPosition.DiscoveredActions.AddLast(new AgO<GWAction<PositionData, ActionData>, GWPosition<PositionData, ActionData>>(bestOption, null));
//CurrentPosition.DiscoveredActions.AddLast(new AgO<GWAction<PositionData, ActionData>, GWPosition<PositionData, ActionData>>(bestOption, newPosition));
CurrentPosition = newPosition;
isnewPosition = true;
}
}
}
}
catch (Exception e)
{
Log.Error(e);
}
}
public void RomanNumeralCharacterCausesSuccessfullAttempt()
{
string[] inRoman = { "III" };
Attempt <string> result = _inputConverter.Convert(inRoman);
Assert.IsFalse(result.Failed);
}