private CompassDirection GetCompassDirection(string[] lineParts) { CompassDirection compassDirection = CompassDirection.North; switch (lineParts[2][0]) { case 'N': compassDirection = CompassDirection.North; break; case 'E': compassDirection = CompassDirection.East; break; case 'S': compassDirection = CompassDirection.South; break; case 'W': compassDirection = CompassDirection.West; break; } return(compassDirection); }
private void CalculateCompassDirection() { Vector2 vec = Vector2.zero; if (_previousRail == null && _nextRail == null) { CompassDirection = CompassDirection.E; return; } else if (_previousRail == null) { vec = _nextRail.Position - Position; } else if (_nextRail == null) { vec = Position - _previousRail.Position; } else { vec = _nextRail.Position - _previousRail.Position; } float angle = Mathf.Atan2(y: vec.y, x: vec.x); int octant = Mathf.RoundToInt(f: 8 * angle / (2 * Mathf.PI) + 8) % 8; CompassDirection = (CompassDirection)octant; }
private void ExitRoom(Room room, CompassDirection wallLocation) { if (room.Trap != null && room.Trap.TrippedOrDisarmed == false) { ProcessTrapMessagesAndDamage(room.Trap); room.Trap.TrippedOrDisarmed = true; } var exit = room.Exits.FirstOrDefault(x => x.WallLocation == wallLocation); if (exit == null) { throw new Exception("this room doesnt have that exception"); } var newRoom = gameAdventure.Rooms.FirstOrDefault(x => x.RoomNumber == exit.LeadsToRoomNumber); if (newRoom == null) { throw new Exception("The room that this previous room was supposed to lead too does not exist!? Dragons? Or maybe a bad author!!!"); } if ((exit.Lock == null || !exit.Lock.Locked) || TryUnlock(exit.Lock)) { RoomProcessor(newRoom); } else { RoomProcessor(room); } }
public Collision(CompassDirection side, Rectangle intersectionRec, object collider, object collidee) { Side = side; IntersectionRec = intersectionRec; Collider = collider; Collidee = collidee; }
/// <summary> /// Returns the direction right of current. /// </summary> /// <param name="currentFacing"></param> /// <returns></returns> public CompassDirection TurnRight(CompassDirection currentFacing) { var current = (int)currentFacing + 1; if (current == 8) current = 0; return (CompassDirection)current; }
public void TurnRight(CompassDirection originalFacing, CompassDirection expectedFacing) { var compass = new Compass(); var newFacing = compass.RightTurns[originalFacing]; Assert.AreEqual(expectedFacing, newFacing); }
public RoverSpec(int x, int y, CompassDirection facing, RoverInstruction[] instructions) { X = x; Y = y; Facing = facing; Instructions = instructions ?? throw new ArgumentNullException(nameof(instructions)); }
public CompassDirection GetCompassDirection(Point3D loc) { int i = loc.Y - m_Bounds.Y; int j = loc.X - m_Bounds.X; CompassDirection dir = CompassDirection.None; if (i > 0 && i < (m_Bounds.Height - 1)) { if (j > 0 && !m_Traps[i - 1][j - 1]) { dir |= CompassDirection.West; } if (j < (m_Bounds.Width - 1) && !m_Traps[i - 1][j + 1]) { dir |= CompassDirection.East; } } if (i > 0 && (i == 1 || !m_Traps[i - 2][j])) { dir |= CompassDirection.North; } if (i < (m_Bounds.Height - 1) && (i == m_Bounds.Height - 2 || !m_Traps[i][j])) { dir |= CompassDirection.South; } return(dir); }
public static float WindDirToInverseAngle(CompassDirection cdir) { switch (cdir) { case CompassDirection.N: return(180f); case CompassDirection.E: return(270f); case CompassDirection.W: return(90f); case CompassDirection.S: return(0f); case CompassDirection.NE: return(225f); case CompassDirection.NW: return(125f); case CompassDirection.SE: return(315f); case CompassDirection.SW: return(45f); default: return(0f); } }
/// <summary> /// Generate a (possibly multi-tile) doorway /// </summary> /// <param name="i"></param> /// <param name="j"></param> /// <param name="direction"></param> /// <param name="template"></param> /// <param name="template2"></param> /// <param name="floorLevel"></param> protected void GenerateDoorway(int i, int j, CompassDirection direction, int width) { for (int n = -1; n < width + 1; n++) { int iA = i; int jA = j; if (direction == CompassDirection.North || direction == CompassDirection.South) { iA += n; } else { jA += n; } if (n < 0 || n > width) { SetCell(i, j, CellGenerationType.WallCorner); } else { SetCell(i, j, CellGenerationType.Door); } } }
public Rover(int x, int y, CompassDirection facing, int maxX, int maxY, Compass compass) { this.compass = compass ?? throw new ArgumentNullException(nameof(compass)); if (x < 0 || x > maxX) { throw new ArgumentException(nameof(x)); } if (y < 0 || y > maxY) { throw new ArgumentException(nameof(y)); } if (!compass.ValidDirections.Contains(facing)) { throw new ArgumentException(nameof(facing)); } X = x; Y = y; Facing = facing; this.maxX = maxX; this.maxY = maxY; }
/// <summary> /// Choose a random point on the outside edge of this rectangle /// </summary> /// <param name="edge"></param> /// <param name="rng"></param> /// <param name="endOffset"></param> /// <param name="i"></param> /// <param name="j"></param> public void RandomPointOnEdge(CompassDirection edge, Random rng, int endOffset, ref int i, ref int j) { if (edge == CompassDirection.North) { j = YMax + 1; } else if (edge == CompassDirection.East) { i = XMax + 1; } else if (edge == CompassDirection.South) { j = YMin - 1; } else if (edge == CompassDirection.West) { i = XMin - 1; } if (edge.IsHorizontal()) { j = rng.Next(YMin, YMax - endOffset + 1); } else { i = rng.Next(XMin, XMax - endOffset + 1); } }
public void Transform_NotInvalidCompassDirection_ReturnsNewPosition( CompassDirection currentCompassDirection, int currentX, int currentY, int expectedOutputX, int expectedOutputY) { var currentState = this.mockRepository.Create <IRobotState>(); currentState.Setup(s => s.GetCompassDirection()).Returns(currentCompassDirection); currentState.Setup(s => s.GetX()).Returns(currentX); currentState.Setup(s => s.GetY()).Returns(currentY); var robotStateBuilder = this.mockRepository.Create <IRobotStateBuilder>(); this.robotStateBuilderFactory .Setup(f => f.CreateBuilderFromPrototype(currentState.Object)) .Returns(robotStateBuilder.Object); robotStateBuilder.Setup( b => b.WithX(expectedOutputX)).Returns(robotStateBuilder.Object); robotStateBuilder.Setup( b => b.WithY(expectedOutputY)).Returns(robotStateBuilder.Object); var expectedState = this.mockRepository.Create <IRobotState>(); robotStateBuilder.Setup(b => b.Build()).Returns(expectedState.Object); var outputState = this.moveStateTransformer.Transform(currentState.Object); Assert.Equal(outputState, expectedState.Object); }
public SquareType MovetoSquare(CompassDirection direction) { moveToSquareX = GetMoveToSquareX(direction); moveToSquareY = GetMoveToSquareY(direction); moveToSquareType = map[moveToSquareX, moveToSquareY]; return(moveToSquareType); }
private CurrentWeather MapCurrentConditionsResponse(CurrentConditionsResponse openWeatherApiResponse) { var currentConditions = new CurrentWeather() { Success = true, ErrorMessage = String.Empty, Location = new CurrentWeather.LocationData() { Name = openWeatherApiResponse.Name, Latitude = openWeatherApiResponse.Coordintates.Latitude, Longitude = openWeatherApiResponse.Coordintates.Longitude }, ObservationTime = DateTimeOffset.FromUnixTimeSeconds(openWeatherApiResponse.ObservationTime + openWeatherApiResponse.TimezoneOffset).DateTime, ObservationTimeUtc = DateTimeOffset.FromUnixTimeSeconds(openWeatherApiResponse.ObservationTime).DateTime, CurrentConditions = new CurrentWeather.WeatherData() { Conditions = openWeatherApiResponse.ObservedConditions.FirstOrDefault()?.Conditions, ConditionsDescription = openWeatherApiResponse.ObservedConditions.FirstOrDefault()?.ConditionsDetail, Visibility = openWeatherApiResponse.Visibility / 1609.0, // Visibility always comes back in meters, even when imperial requested CloudCover = openWeatherApiResponse.Clouds.CloudCover, Temperature = openWeatherApiResponse.ObservationData.Temperature, Humidity = openWeatherApiResponse.ObservationData.Humidity, Pressure = openWeatherApiResponse.ObservationData.Pressure * 0.0295301, // Pressure always comes back in millibars, even when imperial requested WindSpeed = openWeatherApiResponse.WindData.Speed, WindDirection = CompassDirection.GetDirection(openWeatherApiResponse.WindData.Degrees), WindDirectionDegrees = openWeatherApiResponse.WindData.Degrees, RainfallOneHour = (openWeatherApiResponse.Rain?.RainfallOneHour ?? 0.0) * 0.03937008 }, FetchTime = DateTime.Now }; return(currentConditions); }
public static char GetCharByCompassDirection(this CompassDirection compassDirection) { char compassDirectionByChar; switch (compassDirection) { case CompassDirection.North: compassDirectionByChar = 'N'; break; case CompassDirection.West: compassDirectionByChar = 'W'; break; case CompassDirection.South: compassDirectionByChar = 'S'; break; case CompassDirection.East: compassDirectionByChar = 'E'; break; default: throw new ArgumentException(); } return(compassDirectionByChar); }
public static bool IsCardinalDirection(this CompassDirection direction) { return(direction == CompassDirection.Top || direction == CompassDirection.Right || direction == CompassDirection.Bottom || direction == CompassDirection.Left); }
public bool OffsetByOne(CompassDirection direction, out Subtile newTile) { var newX = X; var newY = Y; switch (direction) { case CompassDirection.Top: newX--; newY--; break; case CompassDirection.TopRight: newX--; break; case CompassDirection.Right: newX--; newY++; break; case CompassDirection.BottomRight: newY++; break; case CompassDirection.Bottom: newX++; newY++; break; case CompassDirection.BottomLeft: newX++; break; case CompassDirection.Left: newX++; newY--; break; case CompassDirection.TopLeft: newY--; break; default: throw new ArgumentOutOfRangeException(); } if (newX < 0 || newX >= GameSystems.Location.LocationLimitX * 3 || newY < 0 || newY >= GameSystems.Location.LocationLimitY * 3) { newTile = default; return(false); } else { newTile = new Subtile(newX, newY); return(true); } }
/// <summary> /// Rotates the camera about the cube so that the face adjacent to the current edge in the /// specified face-direction becomes the current face. The input direction is cube /// orientation-agnostic. /// </summary> /// <param name="direction">The direction to rotate towards, relative to the current /// face.</param> public void Rotate( CompassDirection direction ) { Face nextFace = CurrentFace.AdjacentFace( direction ); CompassDirection backDir = nextFace.BackwardsDirectionFrom( CurrentFace ); UpDir = GetNextUpDirection( direction, backDir ); CurrentFace = nextFace; }
public LawnMower(int startX, int startY, CompassDirection initialHeading, ref ILawn lawn) { _heading = initialHeading; _lawn = lawn; XCord = startX; YCord = startY; _lawn.PlaceLawnMower(this, XCord, YCord); }
private void BackOffInDirection(locXY start, CompassDirection relPosCode, int tiles, out locXY locOut) { locOut = start; for (int i = 0; i < tiles; i++) { locOut = locOut.Offset(relPosCode); } }
public void ParseCompassDirection_WhenPassingValidCompassDirection() { char ch = 'N'; MowerInput mowerInput = new MowerInput(); CompassDirection direction = MowerInput.ParseCompassDirection(ch); Assert.AreEqual(CompassDirection.North, direction); }
/// <summary> /// Constructor. /// </summary> /// <param name="unit"></param> /// <param name="direction"></param> /// <param name="linkedAnimProcess"></param> /// <param name="delay"></param> public MovementProcess(Unit unit, CompassDirection direction, AnimProcess linkedAnimProcess, Isometry iso, float delay = .015f) : base() { _unit = unit; _direction = direction; _linkedAnimProcess = linkedAnimProcess; _speed = delay; _iso = iso; }
public override void Initialize(BaseCell primary, BaseCell other, CompassDirection direction) { base.Initialize(primary, other, direction); if (OtherSide != null) { // do something with the transform I guess isMirrored = true; } }
protected override string SolvePartOne() { (int x, int y)curPos = (0, 0); CompassDirection curDirection = CompassDirection.E; foreach (var line in Lines) { char instruction = line[0]; int val = int.Parse(line[1..]);
public void Vectors(CompassDirection facing, int expectedX, int expectedY) { var compass = new Compass(); var vector = compass.Vectors[facing]; Assert.AreEqual(facing, vector.Direction); Assert.AreEqual(expectedX, vector.XVector); Assert.AreEqual(expectedY, vector.YVector); }
public void CheckBoundaryBearingsReturCorrectDirectionForIntercardinalDirections(double bearing, string expectedDirection) { // Act var direction = CompassDirection.GetDirection(bearing); // Assert direction.Abbreviation.Should().Be(expectedDirection, $"Expected direction of {expectedDirection} but got {direction.Abbreviation} for bearing {bearing}"); }
/// <summary> /// Rotates the robot with new direction value. /// </summary> /// <param name="newDirectionValue">The new direction value.</param> /// <returns>System.Int32.</returns> private int RotateRobotWithNewDirectionValue(int newDirectionValue) { newDirectionValue = newDirectionValue < 0 ? 3 : newDirectionValue > 3 ? 0 : newDirectionValue; CompassDirection newDirection = (CompassDirection)newDirectionValue; _newPosition = new Position(_currentPosition.Xcoordinate, _currentPosition.Ycoordinate, newDirection); return(newDirectionValue); }
public Model(string Name, CompassDirection Direction, string Icon, RowColumn RowColumn) : base(Name) { this.Direction = Direction; this.Icon = string.Concat(@"pack://application:,,,/Imagin.Controls.Common;component/Images/", Icon, ".png"); this.Row = RowColumn.Row.ToInt32(); this.Column = RowColumn.Column.ToInt32(); this.DefaultRow = RowColumn.Row.ToInt32(); this.DefaultColumn = RowColumn.Column.ToInt32(); }
private int YMoveForDirection(CompassDirection direction) { int[] yMoves = new int[4]; yMoves[(int)CompassDirection.EAST] = -1; yMoves[(int)CompassDirection.WEST] = 1; yMoves[(int)CompassDirection.NORTH] = 0; yMoves[(int)CompassDirection.SOUTH] = 0; return(yMoves[(int)direction]); }
public void CheckBearingsResultInCorrectCompassDirection(double bearing, string expectedDirection) { // Act var direction = CompassDirection.GetDirection(bearing); // Assert direction.Abbreviation.Should().Be(expectedDirection, $"Expected direction of {expectedDirection} but got {direction.Abbreviation} for bearing {bearing}"); }
static void Main(string[] args) { string inputFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "../../input.txt"); string inputs = File.ReadAllText(inputFilePath); Location currentLocation = new Location(); Location EasterHQ = null; CompassDirection currentDirection = CompassDirection.North; List <Location> previouslyVisitedLocations = new List <Location>();; foreach (var input in inputs.Split(',')) { string instruction = input.Trim(); char leftOrRight = instruction[0]; int distance = int.Parse(instruction.Substring(1)); if (leftOrRight == 'L') { currentDirection = turn(true, currentDirection); } else if (leftOrRight == 'R') { currentDirection = turn(false, currentDirection); } else { throw new Exception("leftOrRight invalid."); } for (int i = 0; i < distance; i++) { followDirections(currentDirection, 1, currentLocation); if (EasterHQ == null && previouslyVisitedLocations.Contains(currentLocation)) { Console.WriteLine(string.Format("We've been here before! ({0},{1})", currentLocation.X, currentLocation.Y)); EasterHQ = new Location() { X = currentLocation.X, Y = currentLocation.Y }; } previouslyVisitedLocations.Add(new Location() { X = currentLocation.X, Y = currentLocation.Y }); } } Console.WriteLine("Final Location: " + currentLocation.ToString()); Console.WriteLine(string.Format("Shortest Distance:{0}", Math.Abs(currentLocation.X) + Math.Abs(currentLocation.Y))); Console.WriteLine("Easter Location: " + EasterHQ.ToString()); Console.WriteLine(string.Format("Shortest Distance:{0}", Math.Abs(EasterHQ.X) + Math.Abs(EasterHQ.Y))); Console.ReadLine(); }
public void TurnRight(CompassDirection originalFacing, CompassDirection expectedNewFacing) { var rover = new Rover(5, 6, originalFacing, MAX_X, MAX_Y, compass); rover.TurnRight(); Assert.AreEqual(5, rover.X); Assert.AreEqual(6, rover.Y); Assert.AreEqual(expectedNewFacing, rover.Facing); }
public void Move(CompassDirection originalFacing, int expectedX, int expectedY) { var rover = new Rover(3, 6, originalFacing, MAX_X, MAX_Y, compass); rover.Move(); Assert.AreEqual(expectedX, rover.X); Assert.AreEqual(expectedY, rover.Y); Assert.AreEqual(originalFacing, rover.Facing); }
public CompassDirection LawnMowerSetNewHeading_CalledWithCurrentHeadingAndARotation_SetsLawnMowerHeading(CompassDirection compassDirection, int rotation) { //Arrange ILawn lawn = new Lawn(5, 5); var lawnMower = new LawnMowerWithPublicMethods(0, 0, compassDirection, ref lawn); //Act lawnMower.SetNewHeading(rotation); //Assert return lawnMower.Heading; }
public CompassGump( CompassDirection dir ) : base( 100, 100 ) { AddImage( 0, 0, 0x232F ); AddAlphaRegion( 0, 0, 200, 200 ); if ( ( dir & CompassDirection.West ) != 0 ) AddImage( 50, 50, 0x119B ); if ( ( dir & CompassDirection.North ) != 0 ) AddImage( 100, 50, 0x1195 ); if ( ( dir & CompassDirection.South ) != 0 ) AddImage( 50, 100, 0x1199 ); if ( ( dir & CompassDirection.East ) != 0 ) AddImage( 100, 100, 0x1197 ); }
protected void MoveSolid( Solid solid, CompassDirection dir ) { Face nextFace = AdjacentFace( dir ); var backDir = nextFace.BackwardsDirectionFrom( this ); mSolids.Remove( solid ); solid.World = nextFace.World; nextFace.mSolids.Add( solid ); Body body = solid.Body; float pastRotation = body.Rotation; body.Rotation += nextFace.Rotation; body.AdHocGravity = Vector2.UnitY.Rotate( -body.Rotation ).Rounded(); body.Awake = true; body.Position = body.Position.Rotate( pastRotation - body.Rotation ); body.LinearVelocity = body.LinearVelocity.Rotate( pastRotation - body.Rotation ); }
protected void SetNewHeading(int rotation) // -1 for left 90 degrees or 1 right 90 degrees { var newHeadingInt = -1; switch (_heading) { case CompassDirection.N: newHeadingInt = (4 + (0 + rotation)) % 4; break; case CompassDirection.E: newHeadingInt = (4 + (1 + rotation)) % 4; break; case CompassDirection.S: newHeadingInt = (4 + (2 + rotation)) % 4; break; case CompassDirection.W: newHeadingInt = (4 + (3 + rotation)) % 4; break; } _heading = (CompassDirection)newHeadingInt; }
protected override void ApplyRotation( CompassDirection dir ) { base.ApplyRotation( dir ); mModelRotation.Value = Rotation; if ( IsActive ) Cube.Rotate( dir ); }
public LawnMowerWithPublicMethods(int startX, int startY, CompassDirection initHeading, ref ILawn lawn) : base(startX, startY, initHeading, ref lawn) { }
public Face AdjacentFace( CompassDirection direction ) { switch ( direction ) { case CompassDirection.North: return NorthFace; case CompassDirection.East: return EastFace; case CompassDirection.South: return SouthFace; case CompassDirection.West: return WestFace; } throw new Tools.WtfException(); }
private void CreateFan(CompassDirection direction) { var fan = engine.CreateFan(direction, RelativeHeight.AnyHeight); fans.Add((eDirection)direction, fan); }
public new static void GetLawnMowerXyHeading(string xYHeadingArgs, out int x, out int y, out CompassDirection heading) { Program.GetLawnMowerXyHeading(xYHeadingArgs, out x, out y, out heading); }
/// <summary> /// Returns a location a given direction and distance away from the start location. /// </summary> /// <param name="startTile"></param> /// <param name="dir"></param> /// <param name="distance"></param> /// <returns></returns> public Point TileWalker(Point startTile, CompassDirection dir, int distance) { var p = startTile; for (var i = 0; i < distance; i++) p = TileWalker(p, dir); return p; }
protected static void GetLawnMowerXyHeading(string xYHeadingArgs, out int x, out int y, out CompassDirection heading) { string[] lawnMower1StartxYHeadingArg = xYHeadingArgs.Split(new[] { " " }, StringSplitOptions.None); Int32.TryParse(lawnMower1StartxYHeadingArg[0], out x); Int32.TryParse(lawnMower1StartxYHeadingArg[1], out y); Enum.TryParse(lawnMower1StartxYHeadingArg[2], out heading); }
/// <summary> /// Returns the tile location adjacent to the passed tile location in the given direction. /// </summary> /// <param name="startTile"></param> /// <param name="dir"></param> /// <returns></returns> public Point TileWalker(Point startTile, CompassDirection dir) { var p = new Point(startTile.X, startTile.Y); switch (Style) { case IsometricStyle.Diamond: switch (dir) { case CompassDirection.North: p.X--; p.Y--; break; case CompassDirection.NorthEast: p.Y--; break; case CompassDirection.East: p.X++; p.Y--; break; case CompassDirection.SouthEast: p.X++; break; case CompassDirection.South: p.X++; p.Y++; break; case CompassDirection.SouthWest: p.Y++; break; case CompassDirection.West: p.X--; p.Y++; break; case CompassDirection.NorthWest: p.X--; break; } break; case IsometricStyle.Slide: switch (dir) { case CompassDirection.North: p.X++; p.Y -= 2; break; case CompassDirection.NorthEast: p.X++; p.Y--; break; case CompassDirection.East: p.X++; break; case CompassDirection.SouthEast: p.Y++; break; case CompassDirection.South: p.X--; p.Y += 2; break; case CompassDirection.SouthWest: p.X--; p.Y++; break; case CompassDirection.West: p.X--; break; case CompassDirection.NorthWest: p.Y--; break; } break; case IsometricStyle.Staggered: switch (dir) { case CompassDirection.North: p.Y -= 2; break; case CompassDirection.NorthEast: p.X += (startTile.Y & 1); p.Y--; break; case CompassDirection.East: p.X++; break; case CompassDirection.SouthEast: p.Y++; p.X += (startTile.Y & 1); break; case CompassDirection.South: p.Y += 2; break; case CompassDirection.SouthWest: p.Y++; p.X += ((startTile.Y & 1) - 1); break; case CompassDirection.West: p.X--; break; case CompassDirection.NorthWest: p.Y--; p.X += ((startTile.Y & 1 )- 1); break; } break; } return p; }
protected virtual void ApplyRotation( CompassDirection dir ) { mRotated = true; Cube.Face nextFace = CubeFace.AdjacentFace( dir ); var backDir = nextFace.BackwardsDirectionFrom( CubeFace ); float mass = Body.Mass; Body body = Body.DeepClone( nextFace.World ); CubeFace.World.RemoveBody( Body ); Body = body; Body.Mass = mass; float pastUpDirAngle = UpDir.Angle; float rotDif = UpDir.Angle - Rotation; UpDir = Cube.GetNextUpDirection( UpDir, dir, backDir ); CubeFace = nextFace; Rotation -= rotDif; Body.Position = ComputeFacePosition().ToUnits(); Velocity = Velocity.Rotate( UpDir.Angle - pastUpDirAngle ); ReconstructBody(); }
public List<Tuple<ILawnMower, string>> MowersWithMovementInstructions { get; } //string repsresents MovementInstructions public void AddLawnMower(int x, int y, CompassDirection initialHeading, string movementInstructions) { var lawnMower = new LawnMower(x, y, initialHeading, ref _lawn); MowersWithMovementInstructions.Add(new Tuple<ILawnMower, string>(lawnMower, movementInstructions)); }
/// <summary> /// Returns the direction left of current. /// </summary> /// <param name="currentFacing"></param> /// <returns></returns> public CompassDirection TurnLeft(CompassDirection currentFacing) { var current = (int)currentFacing - 1; if (current == -1) current = 7; return (CompassDirection)current; }
/// <summary> /// Rotates the camera about the cube so that the face adjacent to the current edge in the /// specified face-direction becomes the current face. The input direction is cube /// orientation-agnostic. This is a convenience overload accepting a /// Nullable<CompassDirection> as a parameter. /// </summary> /// <param name="direction">The direction to rotate towards, relative to the current /// face, or null for no rotation.</param> public void Rotate( CompassDirection? direction ) { if ( direction.HasValue ) Rotate( direction.Value ); }
private void CreateRumble(CompassDirection direction) { var rumble = engine.CreateRumble(direction, RelativeHeight.AnyHeight); rumbles.Add((eDirection)direction, rumble); }
private void CreateLight(CompassDirection direction) { var light = engine.CreateLight(direction, RelativeHeight.AnyHeight); lights.Add((eDirection)direction, light); }