/// <summary> /// Handler for when slide manipulation is complete /// </summary> private void ContentGrid_ManipulationCompleted(object sender, ManipulationCompletedRoutedEventArgs e) { if (!MouseSlidingEnabled && e.PointerDeviceType == PointerDeviceType.Mouse) { return; } var x = _transform.TranslateX; _contentAnimation.From = x; _contentStoryboard.Begin(); _leftCommandTransform.TranslateX = 0; _rightCommandTransform.TranslateX = 0; _leftCommandPanel.Opacity = 1; _rightCommandPanel.Opacity = 1; if (x < -ActivationWidth) { RightCommandRequested?.Invoke(this, new EventArgs()); RightCommand?.Execute(null); } else if (x > ActivationWidth) { LeftCommandRequested?.Invoke(this, new EventArgs()); LeftCommand?.Execute(null); } }
/// <summary> /// Handler for when slide manipulation is complete /// </summary> private void ContentGrid_ManipulationCompleted(object sender, ManipulationCompletedRoutedEventArgs e) { if (SwipeStatus == SwipeStatus.Idle) { return; } var x = _transform.TranslateX; _contentAnimation.From = x; _commandContainerClipTranslateAnimation.From = 0; _commandContainerClipTranslateAnimation.To = -x; _contentStoryboard.Begin(); if (SwipeStatus == SwipeStatus.SwipingPassedLeftThreshold) { RightCommandRequested?.Invoke(this, EventArgs.Empty); RightCommand?.Execute(RightCommandParameter); } else if (SwipeStatus == SwipeStatus.SwipingPassedRightThreshold) { LeftCommandRequested?.Invoke(this, EventArgs.Empty); LeftCommand?.Execute(LeftCommandParameter); } Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { SwipeStatus = SwipeStatus.Idle; }).AsTask(); }
void Update() { if (Input.GetKey(KeyCode.UpArrow)) { moveUp = new UpCommand(this.transform, _speed); moveUp.Execute(); MoveGameManager.Instance.AddCommand(moveUp); } if (Input.GetKey(KeyCode.DownArrow)) { moveDown = new DownCommand(this.transform, _speed); moveDown.Execute(); MoveGameManager.Instance.AddCommand(moveDown); } if (Input.GetKey(KeyCode.LeftArrow)) { moveLeft = new LeftCommand(this.transform, _speed); moveLeft.Execute(); MoveGameManager.Instance.AddCommand(moveLeft); } if (Input.GetKey(KeyCode.RightArrow)) { moveRight = new RightCommand(this.transform, _speed); moveRight.Execute(); MoveGameManager.Instance.AddCommand(moveRight); } }
public void RotateRobotToLeft() { /* * Should rotate the Robot without moving it * 1. Test initial state * 2. Place the robot * 3. 360 degrees rotation */ //1 Assert.Throws <ToyRobotHasNotBeenPlacedException>(() => toyRobot.GetCurrentPosition()); Assert.IsFalse(toyRobot.HasBeenPlaced()); //2 var args = "0,0,WEST"; PlaceCommand placeCommand = new PlaceCommand(map, args); toyRobot.Execute(placeCommand); //3 LeftCommand leftCommand = new LeftCommand(map, string.Empty); toyRobot.Execute(leftCommand); Assert.IsTrue(toyRobot.GetCurrentPosition().Item3 == FacesEnum.SOUTH); toyRobot.Execute(leftCommand); Assert.IsTrue(toyRobot.GetCurrentPosition().Item3 == FacesEnum.EAST); toyRobot.Execute(leftCommand); Assert.IsTrue(toyRobot.GetCurrentPosition().Item3 == FacesEnum.NORTH); toyRobot.Execute(leftCommand); Assert.IsTrue(toyRobot.GetCurrentPosition().Item3 == FacesEnum.WEST); }
public void Robot_TestMultipleMovement_RobotReportsCorrectLocation() { Robot robot = new Robot(); Tabletop table = new Tabletop(5, 5); RobotCommander commander = new RobotCommander(); PlaceCommand place = new PlaceCommand(robot, table); place.Direction = "North"; MoveCommand move = new MoveCommand(robot, table); RightCommand right = new RightCommand(robot); LeftCommand left = new LeftCommand(robot); commander.Commands.Enqueue(place); commander.Commands.Enqueue(move); commander.Commands.Enqueue(move); commander.Commands.Enqueue(right); commander.Commands.Enqueue(move); commander.Commands.Enqueue(left); commander.Commands.Enqueue(left); commander.ExecuteCommands(); Assert.Equal(Facing.West, robot.Direction); Assert.Equal(2, robot.Position.Y); Assert.Equal(1, robot.Position.X); }
public HeaderView() { InitializeComponent(); TapGestureRecognizer LeftClickTGR = new TapGestureRecognizer(); LeftClickTGR.Tapped += (object sender, EventArgs e) => { if (LeftCommand != null) { LeftCommand.Execute(this); } }; LeftImageView.GestureRecognizers.Add(LeftClickTGR); TapGestureRecognizer RightClickTGR = new TapGestureRecognizer(); RightClickTGR.Tapped += (object sender, EventArgs e) => { if (RightCommand != null) { RightCommand.Execute(this); } }; RightImageView.GestureRecognizers.Add(RightClickTGR); }
public Command CreateCommand(char commandChar, Engine engine) { Command command = null; switch (commandChar) { case 'V': command = new DownCommand(engine); break; case '^': command = new UpCommand(engine); break; case '<': command = new LeftCommand(engine); break; case '>': command = new RightCommand(engine); break; default: throw new ArgumentException("Invalid command!"); } return(command); }
public IList <ICommand> Build(string robotCommandsInput) { IList <ICommand> commands = new List <ICommand>(); foreach (var commandInput in robotCommandsInput.ToCharArray()) { ICommand command; switch (commandInput) { case 'R': command = new RightCommand(); break; case 'L': command = new LeftCommand(); break; case 'M': command = new MoveCommand(); break; default: throw new InvalidRobotCommandException(); } commands.Add(command); } return(commands); }
public void Robot_TestUndoWhenWhenRobotIsStuckAgainstSouthWall_RobotReportsOrignalPosition() { Robot robot = new Robot(); Tabletop table = new Tabletop(5, 5); RobotCommander commander = new RobotCommander(); PlaceCommand place = new PlaceCommand(robot, table); place.Direction = "North"; MoveCommand move = new MoveCommand(robot, table); RightCommand right = new RightCommand(robot); LeftCommand left = new LeftCommand(robot); commander.Commands.Enqueue(place); commander.Commands.Enqueue(right); commander.Commands.Enqueue(right); commander.Commands.Enqueue(move); commander.ExecuteCommands(); commander.UndoCommands(1); Assert.Equal(0, robot.Position.Y); Assert.Equal(0, robot.Position.X); }
public string Operation() { var areaResult = new AreaResult(_Direction, _Coordinate); foreach (var command in _Commands) { Command.Base.Command cmd; switch (command) { case 'L': cmd = new LeftCommand(areaResult.Direction, areaResult.Coordinate); break; case 'R': cmd = new RightCommand(areaResult.Direction, areaResult.Coordinate); break; case 'M': cmd = new MoveCommand(areaResult.Direction, areaResult.Coordinate); break; default: throw new ArgumentException($"Invalid command parameter {command}"); } areaResult = cmd.Execute(); if (!_GridArea.ValidPosition(areaResult.Coordinate)) { throw new ArgumentOutOfRangeException($"Coordinate unknow {areaResult.Coordinate}"); } } return(areaResult.ToString()); }
// Update is called once per frame void Update() { if (Input.GetKey(KeyCode.UpArrow)) { ICommand command = new UpCommand(this.transform, this._speed); command.Execute(); CommandManager.Instance.AddCommand(command); } else if (Input.GetKey(KeyCode.DownArrow)) { ICommand command = new DownCommand(this.transform, this._speed); command.Execute(); CommandManager.Instance.AddCommand(command); } else if (Input.GetKey(KeyCode.RightArrow)) { ICommand command = new RightCommand(this.transform, this._speed); command.Execute(); CommandManager.Instance.AddCommand(command); } else if (Input.GetKey(KeyCode.LeftArrow)) { ICommand command = new LeftCommand(this.transform, this._speed); command.Execute(); CommandManager.Instance.AddCommand(command); } else if (Input.GetKeyDown(KeyCode.Space)) { CommandManager.Instance.Reverse(); } }
public void Setup() { _leftCommand = new LeftCommand(); _robot = new Robot(X, Y) { CurrentPosition = new Position(X, Y, Facing.N) }; }
private static IMovementService GetMovementService() { var leftCommand = new LeftCommand(); var rightCommand = new RightCommand(); var moveCommand = new MoveCommand(); return(new MovementService(leftCommand, rightCommand, moveCommand)); }
public async Task ShouldFailValidationRobotNotOnTheTableTest() { var leftCommand = new LeftCommand(); Robot robot = new Robot(Table.GetTableInstance()); var result = await leftCommand.Excute(robot); result.ShouldBe(false); }
public void LeftCommand_WithoutSetCurrentPosition_Returns_UnchangedPosition() { ICommand leftCommand = new LeftCommand(new string[] { }); Position currentPosition = null; IPositionValidator positionValidator = new PositionValidator(5, 5); Position newPosition = leftCommand.Execute(currentPosition, positionValidator); Assert.IsNull(newPosition); }
public void Setup() { _command = new LeftCommand(); _gridMock = new Mock <IGrid>(); _gridMock.Setup(x => x.Width).Returns(5); _gridMock.Setup(x => x.Height).Returns(5); _robot = Robot.Construct("3 3 N", _gridMock.Object); }
public void CheckNotPlaced() { var command = new LeftCommand(); var robot = new Robot() { Placed = false }; Assert.False(Program.CheckValidCommand(command, robot)); }
public void EastLeftTest() { var currRobot = new Robot() { Dir = Face.South }; var command = new LeftCommand(); currRobot = command.Execute("Left", currRobot); Assert.Equal(Face.East, currRobot.Dir); }
public void When_Given_Direction_and_Coordinates_Then_It_Should_LeftCommand_Execute(int x, int y) { ICoordinate coordinate = new Coordinate(x, y); IDirection direction = new EastDirection(); ICommand command = new LeftCommand(direction, coordinate); var result = command.Execute(); result.Should().NotBeNull(); result.Coordinate.Should().NotBeNull(); result.Direction.Should().NotBeNull(); }
public void ShouldNotTurnInvalidRobot() { var robot = new Robot(); var command = new LeftCommand(); command.Execute(robot); Assert.Equal(Direction.Invalid, robot.Direction); Assert.Equal(Coordinate.Invalid, robot.Coordinate); }
void Start() { ICommand up = new UpCommand(); ICommand down = new DownCommand(); ICommand left = new LeftCommand(); ICommand right = new RightCommand(); dict.Add(KeyCode.W, up); dict.Add(KeyCode.S, down); dict.Add(KeyCode.A, left); dict.Add(KeyCode.D, right); }
public async Task ShouldSucceedTest(Direction from, Direction expected) { var leftCommand = new LeftCommand(); Robot robot = new Robot(Table.GetTableInstance()); robot.SetPositionOnTable(new Position(0, 0, from)); var result = await leftCommand.Excute(robot); result.ShouldBe(true); robot.Direction.ShouldBe(expected); }
private void Start() { rightCom = new RightCommand(); leftCom = new LeftCommand(); attackCom = new AttackCommand(); jumpCom = new JumpCommand(); crouchCom = new CrouchCommand(); idleCom = new IdleCommand(); specialCom = new SpecialCommand(); altSpecialCom = new AltSpecialCommand(); mindControlCom = new MindControlCommand(); }
void Start() { ICommand up = new UpCommand(); ICommand down = new DownCommand(); ICommand left = new LeftCommand(); ICommand right = new RightCommand(); dict.Add(KeyCode.UpArrow, up); dict.Add(KeyCode.DownArrow, down); dict.Add(KeyCode.LeftArrow, left); dict.Add(KeyCode.RightArrow, right); }
public void LeftCommandWrap() { var mockTable = Mock.Of <ITableTop>(); var robot = new Robot() { X = 0, Y = 0, DirectionFacing = Direction.North }; var command = new LeftCommand(); command.Execute(robot, mockTable); Assert.AreEqual(robot.DirectionFacing, Direction.West); }
/// <summary> /// Handler for when slide manipulation is complete /// </summary> private void ContentGrid_ManipulationCompleted(object sender, ManipulationCompletedRoutedEventArgs e) { if ((!MouseSlidingEnabled && e.PointerDeviceType == PointerDeviceType.Mouse) || (!IsLeftCommandEnabled && !IsRightCommandEnabled)) { return; } var endcapX = _endcapPathTransform.TranslateX; _endcapPathAnimation.From = endcapX; var startcapX = _startcapPathTransform.TranslateX; _startcapAnimation.From = startcapX; var x = _transform.TranslateX; _contentAnimation.From = x; _commandContainerClipTranslateAnimation.From = 0; _commandContainerClipTranslateAnimation.To = -x; if (x > _startcapPath.ActualWidth) { double unitsPerMs = x / FinishAnimationDuration; double distanceTillStartCap = x - _startcapPath.ActualWidth; double millisecondsTillStartCap = distanceTillStartCap / unitsPerMs; _startcapAnimation.BeginTime = TimeSpan.FromMilliseconds(millisecondsTillStartCap); double millisecondsFromStartCapToEnd = _startcapPath.ActualWidth / unitsPerMs; _startcapAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(millisecondsFromStartCapToEnd)); } else { _startcapAnimation.BeginTime = null; _startcapAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(FinishAnimationDuration)); } _contentStoryboard.Begin(); if (SwipeStatus == SwipeStatus.SwipingPassedLeftThreshold) { RightCommandRequested?.Invoke(this, new EventArgs()); RightCommand?.Execute(RightCommandParameter); } else if (SwipeStatus == SwipeStatus.SwipingPassedRightThreshold) { LeftCommandRequested?.Invoke(this, new EventArgs()); LeftCommand?.Execute(LeftCommandParameter); } Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { SwipeStatus = SwipeStatus.Idle; }).AsTask(); }
public void ShouldParseCommand(string commandline, bool shouldParse) { var command = LeftCommand.Parse(commandline); if (shouldParse) { Assert.NotNull(command); } else { Assert.Null(command); } }
private void TryExecuteCommand(double x) { if (x < -ActivationOffset) { RightCommandRequested?.Invoke(this, new EventArgs()); RightCommand?.Execute(RightCommandParameter); } else if (x > ActivationOffset) { LeftCommandRequested?.Invoke(this, new EventArgs()); LeftCommand?.Execute(LeftCommandParameter); } }
public void LeftCommand_Should_Call_Create_Method_When_Expected_Value() { //Given _roverService.Setup(s => s.GetCurrentRover()).Returns(new RoverPositionModel(1, 1, Direction.North)); var rightCommand = new LeftCommand(_roverService.Object, _directionService.Object); //When rightCommand.Execute(); //Than _directionService.Verify(mock => mock.Left(Direction.North), Times.Once); }
/// <summary> /// Makes from a string and value a command /// </summary> /// <param name="command"></param> /// <param name="value"></param> /// <returns>Command</returns> public IDroneCommand makeCommand(string command, double value = 0) { IDroneCommand droneCommand = null; if (command.Equals("Start")) { droneCommand = new StartCommand(_droneController); } else if (command.Equals("Land")) { droneCommand = new LandCommand(_droneController); } else if (command.Equals("Rise")) { droneCommand = new RiseCommand(_droneController, value); } else if (command.Equals("Fall")) { droneCommand = new FallCommand(_droneController, value); } else if (command.Equals("Right")) { droneCommand = new RightCommand(_droneController, value); } else if (command.Equals("Left")) { droneCommand = new LeftCommand(_droneController, value); } else if (command.Equals("Forward")) { droneCommand = new ForwardCommand(_droneController, value); } else if (command.Equals("Backward")) { droneCommand = new BackwardCommand(_droneController, value); } else if (command.Equals("Turn")) { droneCommand = new TurnCommand(_droneController, (int)value); } else if (command.Equals("TakePicture")) { droneCommand = new TakePictureCommand(_droneController, (int)value); } else if (command.Equals("FollowLine")) { droneCommand = new FollowLineCommand(_droneController); } return(droneCommand); }