public async Task <IActionResult> AddRegion(RegionInputDto regionInput)
{
CoordinateParser coordinateParser = new CoordinateParser();
Coordinate[] parsedCoordinates = await coordinateParser.Parse(regionInput.KmlUrl);
Region region = new Region
{
Name = regionInput.Name
};
_context.Add(region);
await _context.SaveChangesAsync();
foreach (Coordinate coordinate in parsedCoordinates)
{
Coordinate coordinateTransition = new Coordinate
{
Lat = coordinate.Lat,
Lng = coordinate.Lng,
RegionId = region.Id,
};
_context.Add(coordinateTransition);
await _context.SaveChangesAsync();
}
return(Ok());
}
public void Test_ParsingCordinates_ShouldReturnArrayOfCordinates()
{
var coordinates = CoordinateParser.Parse("4 8");
Assert.AreEqual(4, coordinates[0]);
Assert.AreEqual(8, coordinates[1]);
}
public void TestItReturnsFalseOnInvalidTryParse()
{
Assert.False(
CoordinateParser.TryParse("abd", "def", out Coordinate returnedCoordinate)
);
Assert.Equal(CoordinateParser.InvalidCoordinate, returnedCoordinate);
}
public void TestItReturnsTrueOnValidTryParse()
{
Assert.True(
CoordinateParser.TryParse("N054.39.27.000", "W006.12.57.000", out Coordinate returnedCoordinate)
);
Assert.Equal(new Coordinate("N054.39.27.000", "W006.12.57.000"), returnedCoordinate);
}
/// <summary>
/// Parse the command and calls the appropriate method
/// </summary>
/// <param name="command">Entered command</param>
private void ExecuteCommand(string command)
{
switch (command)
{
case "exit":
this.isGameRunning = false;
Console.WriteLine("Goodbye!");
break;
case "top":
this.consoleRenderer.PrintTopPlayers(this.topPlayers.PlayersMoves);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
break;
case "restart":
this.StartNewGame();
break;
default:
int[] cordinates = CoordinateParser.Parse(command);
this.Shoot(cordinates);
break;
}
}
private void OnCoordinateParser(DataPackage data)
{
var text = (string)data.Data;
if (text.Contains(","))
{
_coordinate = CoordinateParser.ParsePointValue(text, _coordinate);
AddNewPoint(_coordinate);
return;
}
if (Points.Count == 1)
{
return;
}
var firstPoint = Points[0];
var secondPoint = Points[1];
var newLenght = CoordinateParser.ParseDoubleArgument(0, text);
var distanceRatio = newLenght / firstPoint.Distance(secondPoint);
if (Math.Abs(distanceRatio) < 1e-6)
{
return;
}
AddNewPoint(GeomUtils.BetweenValue(firstPoint, secondPoint, distanceRatio));
}
public void ValidPlayerMoveReturnsCoordinate()
{
var coordinateParser = new CoordinateParser();
var coordinate = coordinateParser.GetNewCoordinate("2,3");
Assert.Equal(1, coordinate.X);
Assert.Equal(2, coordinate.Y);
}
public InputHandler(NumberFormatInfo numberFormatInfo, char[] coordinateDelimiters)
{
_parser = new CoordinateParser
{
Settings = new ParserSettings()
{
NumberFormat = numberFormatInfo,
Delimiters = coordinateDelimiters
}
};
}
private void OnCoordinateParser(DataPackage data)
{
var text = (string)data.Data;
if (text.Contains(","))
{
var coordinate = new Point3D();
CoordinateParser.ParsePointValue(text, coordinate);
AddNewPoint(coordinate);
return;
}
}
public GameLogicIntegrationTests()
{
_configMock = new Mock <IOptions <AppSettings> >(MockBehavior.Strict);
var settingsChecker = new SettingsChecker(_configMock.Object);
var randomWrapper = new RandomWrapper();
var shipFactory = new ShipFactory(_configMock.Object, randomWrapper);
var grid = new Logic.Grid.Grid();
var gridBuilder = new GridBuilder(_configMock.Object, shipFactory, grid);
var coordinateValidator = new CoordinateValidator();
var coordinateParser = new CoordinateParser(coordinateValidator);
_sut = new GameLogic(settingsChecker, gridBuilder, coordinateParser);
}
private void OnCoordinateParser(DataPackage data)
{
var text = (string)data.Data;
if (text.Contains(","))
{
_coordinate = CoordinateParser.ParsePointValue(text, _coordinate);
AddNewPoint(_coordinate);
}
if (Points.Count < 4)
{
return;
}
}
public void BoardPrintsWithMultipleCoordinates()
{
var input = new TestInput(new[] { "1,1", "1,2", "1,3", "2,1", "2,3", "2,2", "3,1", "3,3", "3,2" });
var output = new TestOutput();
var players = new List <Player> {
new Player("Player 1", Token.X, input), new Player("Player 2", Token.O, input)
};
var board = new Board(3);
var coordinateParser = new CoordinateParser();
var testValidator = new TestValidator(true, true);
var game = new Game(output, board, coordinateParser, testValidator);
RunPlayerLoop(players, game);
Assert.Contains("X O X \nO O X \nX X O ", output.CalledText);
}
public void CellOutsideOfBoardBounds_ReturnsNotification()
{
var input = new TestInput(new[] { "4,5", "q" });
var output = new TestOutput();
var players = new List <Player> {
new Player("Player 1", Token.X, input)
};
var board = new TestBoard(new[] { false });
var coordinateParser = new CoordinateParser();
var testValidator = new TestValidator(validCoordinateResults: false, true);
var game = new Game(output, board, coordinateParser, testValidator);
RunPlayerLoop(players, game);
Assert.Contains("Oh no, those coordinates are outside the bounds of this board. Try again...", output.CalledText);
Assert.Equal(2, input.CalledCount);
}
public void DrawCallsExitApp()
{
var input = new TestInput(new[] { "1,1", "1,2", "1,3", "2,1", "2,3", "2,2", "3,1", "3,3", "3,2" });
var output = new TestOutput();
var players = new List <Player> {
new Player("Player 1", Token.X, input), new Player("Player 2", Token.O, input)
};
var board = new Board(3);
var coordinateParser = new CoordinateParser();
var testValidator = new TestValidator(true, true);
var game = new Game(output, board, coordinateParser, testValidator);
RunPlayerLoop(players, game);
Assert.Equal(GameStatus.GameOver, game.GameStatus);
Assert.Equal(9, input.CalledCount);
}
public void DrawReturnsNotification_IfBoardSize3()
{
var input = new TestInput(new[] { "1,1", "1,2", "1,3", "2,1", "2,3", "2,2", "3,1", "3,3", "3,2" });
var output = new TestOutput();
var players = new List <Player> {
new Player("Player 1", Token.X, input), new Player("Player 2", Token.O, input)
};
var board = new Board(3);
var coordinateParser = new CoordinateParser();
var testValidator = new TestValidator(true, true);
var game = new Game(output, board, coordinateParser, testValidator);
RunPlayerLoop(players, game);
Assert.Contains("It's a draw!", output.CalledText);
Assert.Equal(9, input.CalledCount);
}
public void BoardPrintsWithCorrectCoordinates_ImplementationTest()
{
var input = new TestInput(new[] { "1,1", "q" });
var output = new TestOutput();
var players = new List <Player>()
{
new Player("Player 1", Token.X, input)
};
var board = new Board(3);
var coordinateParser = new CoordinateParser();
var validator = new Validator();
var game = new Game(output, board, coordinateParser, validator);
RunPlayerLoop(players, game);
Assert.Contains("X . . \n. . . \n. . . ", output.CalledText);
}
public void InvalidPlayerMoveReturnsNotification_ImplementationTest()
{
var input = new TestInput(new[] { "1", "q" });
var output = new TestOutput();
var players = new List <Player>()
{
new Player("Player 1", Token.X, input)
};
var board = new Board(3);
var coordinateParser = new CoordinateParser();
var validator = new Validator();
var game = new Game(output, board, coordinateParser, validator);
RunPlayerLoop(players, game);
Assert.Contains("Sorry - that format is incorrect! Try again...", output.CalledText);
}
public void ValidPlayerMoveFormatDoesNotPrintError()
{
var input = new TestInput(new[] { "1,2", "q" });
var output = new TestOutput();
var players = new List <Player>()
{
new Player("Player 1", Token.X, input)
};
var board = new TestBoard(new[] { true });
var coordinateParser = new CoordinateParser();
var testValidator = new TestValidator(validCoordinateResults: true, true);
var game = new Game(output, board, coordinateParser, testValidator);
RunPlayerLoop(players, game);
Assert.DoesNotContain("Sorry - that format is incorrect! Try again...", output.CalledText);
Assert.Equal(1, board.CalledCount);
}
public void CellNotAvailable_ReturnsNotification()
{
var input = new TestInput(new[] { "1,1", "q" });
var output = new TestOutput();
var players = new List <Player>()
{
new Player("Player 1", Token.X, input)
};
var board = new TestBoard(new bool[] { false });
var coordinateParser = new CoordinateParser();
var testValidator = new TestValidator(validCoordinateResults: true, true);
var game = new Game(output, board, coordinateParser, testValidator);
RunPlayerLoop(players, game);
Assert.Contains("Oh no, a piece is already at this place! Try again...", output.CalledText);
Assert.Equal(2, input.CalledCount);
}
public void ExitAppCalledOnQInput()
{
var input = new TestInput(new string[] { "q" });
var output = new TestOutput();
var players = new List <Player>()
{
new Player("Player 1", Token.X, input)
};
var board = new Board(3);
var coordinateParser = new CoordinateParser();
var testValidator = new TestValidator(validCoordinateResults: true, true);
var game = new Game(output, board, coordinateParser, testValidator);
RunPlayerLoop(players, game);
Assert.Equal(GameStatus.GameOver, game.GameStatus);
Assert.Equal(1, input.CalledCount);
}
public void WinReturnsNotification()
{
var input = new TestInput(new string[] { "1,1", "1,2", "2,2", "2,3", "3,3" });
var output = new TestOutput();
var players = new List <Player>()
{
new Player("Player 1", Token.X, input), new Player("Player 2", Token.O, input)
};
var board = new Board(3);
var coordinateParser = new CoordinateParser();
var testValidator = new TestValidator(true, true);
var game = new Game(output, board, coordinateParser, testValidator);
RunPlayerLoop(players, game);
Assert.Contains("Congratulations Player 1! You have won!", output.CalledText);
Assert.Equal(5, input.CalledCount);
}
private void InitializeInputs()
{
var solver = new Solver(Document)
{
RuleSet = new RuleSet()
};
var activeViewNo = AttachedView.GetActiveViewNumber();
MouseInput = new MouseEventsInput();
_mouse3DEventsDPipe = new DirectCoordinateMouseEventsPipe(View);
_commandParserPipe = new CoordinateParser();
_commandList = new CommandList(ActionGraph);
ActionGraph.Register(_mouse3DEventsDPipe);
ActionGraph.Register(new ViewInput(View, Viewer, AttachedView.GetActiveView()));
ActionGraph.Register(MouseInput);
ActionGraph.Register(new FacePickerMockPipe(_context, View));
ActionGraph.Register(new DocumentInput(Document));
ActionGraph.Register(new ContextInput(_context));
ActionGraph.Register(new CommandLineViewInputStub());
ActionGraph.Register(new MouseCursorInput(AttachedView.GetActiveView()));
ActionGraph.Register(new RestrictedPlaneInput());
ActionGraph.Register(new CommandLinePrePusherInput());
ActionGraph.Register(new FacePickerVisualFeedbackPipe(_context));
ActionGraph.Register(new InputBase(InputNames.UiElementsItem));
ActionGraph.Register(new GeometricSolverPipe(solver, new SolverDrawer(_context)));
ActionGraph.Register(new NodeSelectInput());
ActionGraph.Register(_commandParserPipe);
ActionGraph.Register(new InputBase(InputNames.CommandParser));
ActionGraph.Register(new DirectSelectionContainerPipe());
ActionGraph.Register(new InputBase(InputNames.MirrorEntireScenePipe));
ActionGraph.Register(new CommandListInput(_commandList));
ActionGraph.Register(new GlobalCapabilitiesInput());
ActionGraph.Register(new DescriptorsFactoryInput());
ActionGraph.Register(new FastToolbarMockInput());
}
public override void OnImportAsset(AssetImportContext ctx)
{
var lines = File.ReadAllLines(ctx.assetPath);
int modeCoordinates = 0;
int maxModeCoordinates = 0;
var coordParser = new CoordinateParser();
var modeParser = new ModeParser();
MoleculeDefinition molecule = new MoleculeDefinition();
foreach (var line in lines)
{
coordParser.ParseLine(molecule, line);
modeParser.ParseLine(molecule, line);
if (molecule.VibrationalModes.Count > 0)
{
var regexBond = " ! R\\d+ +R\\((\\d+),(\\d+)\\)";
var match = Regex.Match(line, regexBond);
if (match.Success)
{
var atom1 = int.Parse(match.Groups [1].Value) - 1;
var atom2 = int.Parse(match.Groups [2].Value) - 1;
molecule.Bonds.Add(new BondDefinition()
{
AtomIndex1 = atom1, AtomIndex2 = atom2
});
}
}
}
ctx.AddObjectToAsset("Data", molecule);
ctx.SetMainObject(molecule);
}
[InlineData("N054.60.44.000", "W006.60.23.000")] // 60 minutes
public void TestItParsesValidCoordinates(string latitude, string longitude)
{
Assert.Equal(new Coordinate(latitude, longitude), CoordinateParser.Parse(latitude, longitude));
}
public CoordinateParserTests()
{
_coordinateValidatorMock = new Mock <ICoordinateValidator>(MockBehavior.Strict);
_sut = new CoordinateParser(_coordinateValidatorMock.Object);
}
private static void CreatePathSegment(char command, SvgPathSegmentList segments, CoordinateParser parser,
bool isRelative)
{
var coords = new float[6];
switch (command)
{
case 'm': // relative moveto
case 'M': // moveto
if (parser.TryGetFloat(out coords[0]) && parser.TryGetFloat(out coords[1]))
{
segments.Add(new SvgMoveToSegment(ToAbsolute(coords[0], coords[1], segments, isRelative)));
}
while (parser.TryGetFloat(out coords[0]) && parser.TryGetFloat(out coords[1]))
{
segments.Add(new SvgLineSegment(segments.Last.End,
ToAbsolute(coords[0], coords[1], segments, isRelative)));
}
break;
case 'a':
case 'A':
bool size;
bool sweep;
while (parser.TryGetFloat(out coords[0]) && parser.TryGetFloat(out coords[1]) &&
parser.TryGetFloat(out coords[2]) && parser.TryGetBool(out size) &&
parser.TryGetBool(out sweep) && parser.TryGetFloat(out coords[3]) &&
parser.TryGetFloat(out coords[4]))
{
// A|a rx ry x-axis-rotation large-arc-flag sweep-flag x y
segments.Add(new SvgArcSegment(segments.Last.End, coords[0], coords[1], coords[2],
(size ? SvgArcSize.Large : SvgArcSize.Small),
(sweep ? SvgArcSweep.Positive : SvgArcSweep.Negative),
ToAbsolute(coords[3], coords[4], segments, isRelative)));
}
break;
case 'l': // relative lineto
case 'L': // lineto
while (parser.TryGetFloat(out coords[0]) && parser.TryGetFloat(out coords[1]))
{
segments.Add(new SvgLineSegment(segments.Last.End,
ToAbsolute(coords[0], coords[1], segments, isRelative)));
}
break;
case 'H': // horizontal lineto
case 'h': // relative horizontal lineto
while (parser.TryGetFloat(out coords[0]))
{
segments.Add(new SvgLineSegment(segments.Last.End,
ToAbsolute(coords[0], segments.Last.End.Y, segments, isRelative, false)));
}
break;
case 'V': // vertical lineto
case 'v': // relative vertical lineto
while (parser.TryGetFloat(out coords[0]))
{
segments.Add(new SvgLineSegment(segments.Last.End,
ToAbsolute(segments.Last.End.X, coords[0], segments, false, isRelative)));
}
break;
case 'Q': // curveto
case 'q': // relative curveto
while (parser.TryGetFloat(out coords[0]) && parser.TryGetFloat(out coords[1]) &&
parser.TryGetFloat(out coords[2]) && parser.TryGetFloat(out coords[3]))
{
segments.Add(new SvgQuadraticCurveSegment(segments.Last.End,
ToAbsolute(coords[0], coords[1], segments, isRelative),
ToAbsolute(coords[2], coords[3], segments, isRelative)));
}
break;
case 'T': // shorthand/smooth curveto
case 't': // relative shorthand/smooth curveto
while (parser.TryGetFloat(out coords[0]) && parser.TryGetFloat(out coords[1]))
{
var lastQuadCurve = segments.Last as SvgQuadraticCurveSegment;
var controlPoint = lastQuadCurve != null
? Reflect(lastQuadCurve.ControlPoint, segments.Last.End)
: segments.Last.End;
segments.Add(new SvgQuadraticCurveSegment(segments.Last.End, controlPoint,
ToAbsolute(coords[0], coords[1], segments, isRelative)));
}
break;
case 'C': // curveto
case 'c': // relative curveto
while (parser.TryGetFloat(out coords[0]) && parser.TryGetFloat(out coords[1]) &&
parser.TryGetFloat(out coords[2]) && parser.TryGetFloat(out coords[3]) &&
parser.TryGetFloat(out coords[4]) && parser.TryGetFloat(out coords[5]))
{
segments.Add(new SvgCubicCurveSegment(segments.Last.End,
ToAbsolute(coords[0], coords[1], segments, isRelative),
ToAbsolute(coords[2], coords[3], segments, isRelative),
ToAbsolute(coords[4], coords[5], segments, isRelative)));
}
break;
case 'S': // shorthand/smooth curveto
case 's': // relative shorthand/smooth curveto
while (parser.TryGetFloat(out coords[0]) && parser.TryGetFloat(out coords[1]) &&
parser.TryGetFloat(out coords[2]) && parser.TryGetFloat(out coords[3]))
{
var lastCubicCurve = segments.Last as SvgCubicCurveSegment;
var controlPoint = lastCubicCurve != null
? Reflect(lastCubicCurve.SecondControlPoint, segments.Last.End)
: segments.Last.End;
segments.Add(new SvgCubicCurveSegment(segments.Last.End, controlPoint,
ToAbsolute(coords[0], coords[1], segments, isRelative),
ToAbsolute(coords[2], coords[3], segments, isRelative)));
}
break;
case 'Z': // closepath
case 'z': // relative closepath
segments.Add(new SvgClosePathSegment());
break;
}
}
public void Test_ParsingCordinates_ShouldThrowInvalidCommand()
{
var coordinates = CoordinateParser.Parse("12");
}
public void TestItReturnsInvalidOnBadData(string latitude, string longitude)
{
Coordinate coordinate = CoordinateParser.Parse(latitude, longitude);
Assert.Equal(CoordinateParser.InvalidCoordinate, coordinate);
}
public CoordinateParserIntegrationTests()
{
var coordinateValidator = new CoordinateValidator();
_sut = new CoordinateParser(coordinateValidator);
}
public void Test_ParsingWrongCordinates_ShouldThrowInvalidCoordinates()
{
var coordinates = CoordinateParser.Parse("asd qwe");
}
public void Test_ParsingOutsideOfGameBoardCordinates_ShouldThrowInvalidCoordinates()
{
var coordinates = CoordinateParser.Parse("22 20");
}
