/// <summary> /// /// </summary> /// <param name="initialFacingDirection"></param> /// <param name="attackAnims">The order of the animations: North, South, East</param> /// <param name="walkAnims">The order of the animations: North, South, East</param> /// <param name="projectileAnims">The order of the animations: North, South, East</param> public GameActor( Game game, CardinalDirection initialFacingDirection, AnimatedSprite[] attackAnims, AnimatedSprite[] walkAnims, AnimatedSprite[] projectileAnims) : this(game) { if ( attackAnims != null && attackAnims.Length == 3 ) { AttackNorthAnim = attackAnims[0]; AttackSouthAnim = attackAnims[1]; AttackEastAnim = attackAnims[2]; } if ( walkAnims != null && walkAnims.Length == 3 ) { WalkNorthAnim = walkAnims[0]; WalkSouthAnim = walkAnims[1]; WalkEastAnim = walkAnims[2]; } if ( projectileAnims != null && projectileAnims.Length == 3 ) { ProjectileNorthAnim = projectileAnims[0]; ProjectileSouthAnim = projectileAnims[1]; ProjectileEastAnim = projectileAnims[2]; } FacingDirection = initialFacingDirection; ReplaceCurrentAnimation( ); }
/// <summary> /// Determines the current direction the sprite is moving in cardinal directions. /// </summary> public static CardinalDirection determineCurrentDirection(Vector2 motion, CardinalDirection orientation) { if (motion.X > 0) { if (motion.Y > 0) orientation = CardinalDirection.Southeast; else if (motion.Y < 0) orientation = CardinalDirection.Northeast; else // y == 0 orientation = CardinalDirection.East; } else if (motion.X < 0) { if (motion.Y > 0) orientation = CardinalDirection.Southwest; else if (motion.Y < 0) orientation = CardinalDirection.Northwest; else // y == 0 orientation = CardinalDirection.West; } else // x == 0 { if (motion.Y > 0) orientation = CardinalDirection.South; else if (motion.Y < 0) orientation = CardinalDirection.North; } return orientation; }
/// <summary> /// Move a facade with a Mock-Robot in the given CardinalDirection and make sure the appropriate methods have been called /// </summary> /// <param name="cardinalDirection"></param> /// <param name="distance"></param> private static void TestMoveSingleFacade(CardinalDirection cardinalDirection, int distance) { var testRobot = new Mock<IRobot>(); testRobot.Setup(x => x.Move(cardinalDirection, distance)); var directionString = cardinalDirection.ToString().First().ToString(); new RobotFacade(testRobot.Object).Move(directionString, distance.ToString()); testRobot.Verify(x => x.Move(cardinalDirection, distance), Times.Once); }
Vector2 velocity; // The projectile's velocity. #endregion Fields #region Constructors /// <summary> /// Constructs a new Projectile object. All projectiles will begin with their orientation/rotation set at the sprite's orientation/rotation. /// </summary> public Projectile() { // Determine the direction the projectile should move. orientation = SpriteManager.Instance.SpriteList[0].Orientation; rotation = SpriteManager.Instance.SpriteList[0].Rotation; // Activate the projectile. IsActive = true; }
public void Composes_arguments_into_expected_report_format(int coordinateX, int coordinateY, CardinalDirection cardinalDirection, string expectedReport) { var point = new Point(coordinateX, coordinateY); var reportComposer = new ConsoleReportComposer(); var report = reportComposer.Compose(point, cardinalDirection); Assert.AreEqual(expectedReport, report); }
private void OnDirectionChanged(CardinalDirection direction) { if (_directional != null) { _gridField.ClearPoints(); _gridField.AddPoints(_directional.GetAreaOfEffect(), AreaOfEffectSprite); _gridField.RebuildMesh(); } }
public string Compose(Point aPoint, CardinalDirection aCardinalDirection) { var reportItem1 = aPoint.X; var reportItem2 = aPoint.Y; var reportItem3 = cardinalDirectionDictionary[aCardinalDirection]; var report = new StringBuilder(); report.AppendFormat("{0} {1} {2}", reportItem1, reportItem2, reportItem3); return report.ToString(); }
public void SetDirection(CardinalDirection direction) { if (_direction != direction) { _direction = direction; if (DirectionChanged != null) { DirectionChanged(_direction); } } }
public ComboBoxRenderRule(string skin = null, CardinalDirection direction = CardinalDirection.South) { Items = new List<Tuple<Texture2D, string>>(); HighlightItem = 0; OpenDirection = direction; Down = false; Skin = skin; }
public void Given_valid_deploy_point_and_direction_exposes_as_properties(int expectedX, int expectedY, CardinalDirection expectedCardinalDirection) { var expectedPoint = new Point(expectedX, expectedY); mockLandingSurface.Setup(x => x.IsValid(expectedPoint)).Returns(true); var rover = new Rover(); rover.Deploy(mockLandingSurface.Object, expectedPoint, expectedCardinalDirection); Assert.AreEqual(expectedPoint, rover.Position); Assert.AreEqual(expectedCardinalDirection, rover.CardinalDirection); }
public void Move(CardinalDirection cardinalDirection, int distance) { Validate(distance, Boundaries.MinDistance, Boundaries.MaxDistance, "s"); _currentNrOfCommands++; var stepsMade = 0; while (stepsMade < distance) { stepsMade++; CurrentCoordinate.OneStep(cardinalDirection); AddVisitedCoordinate(); } }
void BuildBucket(Color color, string layer, CardinalDirection direction) { Bucket bucket = bucketBuilder.BuildBucket(bucketPrefab, bucketSize, overhang, direction, color); bucket.transform.parent = transform; bucket.SetLayer(layer); bucket.MaximumSize = Random.Range(sizeMin, sizeMax); colorToLayer.Add(color, layer); buckets.Add(direction, bucket); }
public void MoveRight() { if (changingLine || !enabled) { return; } CardinalDirection nextCardinalDirection = MainController.Instance.LevelController.Level.NextPartDirection; if (LevelBehaviour.GetDirection(cardinalDirection, nextCardinalDirection) == Direction.Right && nextCardinalDirection != cardinalDirection) { transform.Rotate(0, 90f, 0); cardinalDirection = nextCardinalDirection; SetCorrectPositionForNextPart(); } else if (line != Line.Right) { StartCoroutine(ChangeLine(line + 1)); } }
public Bucket BuildBucket(GameObject bucketPrefab, int bucketSize, int overhang, CardinalDirection direction, Color color) { GameObject bucketGO = (GameObject) Instantiate(bucketPrefab); Bucket bucket = bucketGO.GetComponent<Bucket>(); bucket.Direction = direction; bucket.Color = color; UpdateBucketScaleAndPosition(bucket, bucketSize, overhang); return bucket; }
public void Init() { levelParts = new LinkedList<GameObject>(); DefaultLevelPart beginning = GameObject.Instantiate(DefaultPrefab); beginning.transform.SetParent(transform, false); levelParts.AddLast(beginning.gameObject); characterPartNode = levelParts.First; cardinalDirection = CardinalDirection.North; GenerateParts(); Character = GameObject.Instantiate(CharacterPrefab); Character.transform.SetParent(transform, false); Character.transform.position = beginning.Spawn.position; Character.OnWall += OnWall; Character.Init(); Active = true; }
/// <summary> /// Initializes a new instance of the <see cref="Auction" /> class. /// </summary> /// <param name="dealerPosition">The dealer position.</param> /// <param name="vurnable">The vurnable.</param> public Auction(CardinalDirection dealerPosition, Vurnability vurnable) { if (!vurnable.IsValid()) { throw new ArgumentOutOfRangeException("vurnable"); } if (!dealerPosition.IsValid()) { throw new ArgumentOutOfRangeException("dealerPosition"); } this.Dealer = dealerPosition; this.Bids = new List<PlacedBid>(); TurnToBid = dealerPosition; Vurnable = vurnable; }
bool FillTileFromDirection(CardinalDirection direction, int x, int y) { Tile nextTile = GetNextTileInDirection(direction, x, y); if (nextTile != null) { int nextTileX = (int) nextTile.TilePosition.x; int nextTileY = (int) nextTile.TilePosition.y; tileGridManager.ClearTile(nextTileX, nextTileY); tileGridManager.SetTileAt(x, y, nextTile); Vector3 targetPosition = tileGridManager.GetTileWorldPosition(x, y); tileAnimationManager.MoveTile(nextTile, targetPosition, 5.0f, iTween.EaseType.easeInCirc); return true; } return false; }
public Position AtDirection(CardinalDirection direction) { Position position = new Position(); if (direction == CardinalDirection.North) { position.Row = this.Row - 1; position.Column = this.Column; } else if (direction == CardinalDirection.South) { position.Row = this.Row + 1; position.Column = this.Column; } else if (direction == CardinalDirection.East) { position.Row = this.Row; position.Column = this.Column + 1; } else if (direction == CardinalDirection.West) { position.Row = this.Row; position.Column = this.Column - 1; } else if (direction == CardinalDirection.Northwest) { position.Row = this.Row - 1; position.Column = this.Column - 1; } else if (direction == CardinalDirection.Northeast) { position.Row = this.Row - 1; position.Column = this.Column + 1; } else if (direction == CardinalDirection.Southeast) { position.Row = this.Row + 1; position.Column = this.Column + 1; } else if (direction == CardinalDirection.Southwest) { position.Row = this.Row + 1; position.Column = this.Column - 1; } return position; }
public void OneStep(CardinalDirection cardinalDirection) { switch (cardinalDirection) { case CardinalDirection.East: X += 1; break; case CardinalDirection.West: X -= 1; break; case CardinalDirection.North: Y += 1; break; case CardinalDirection.South: Y -= 1; break; default: throw new ArgumentOutOfRangeException(nameof(cardinalDirection), cardinalDirection, "Unsupported CardinalDirection"); } }
public void When_RoverDeployCommand_type_returns_new_command_from_factory_with_parsed_values( string roverDeployCommand, int expectedX, int expectedY, CardinalDirection expectedCardinalDirection) { var expectedPoint = new Point(expectedX, expectedY); var expectedCommand = new Mock<IRoverDeployCommand>(); Func<Point, CardinalDirection, IRoverDeployCommand> factory = (point, direction) => { expectedCommand.Setup(x => x.DeployPoint).Returns(point); expectedCommand.Setup(x => x.DeployDirection).Returns(direction); return expectedCommand.Object; }; var mockCommandMatcher = createMockCommandMatcher(CommandType.RoverDeployCommand); var commandParser = new CommandParser(mockCommandMatcher.Object, null, factory, null); var actualCommand = (IRoverDeployCommand) commandParser.Parse(roverDeployCommand).First(); Assert.AreEqual(expectedCommand.Object, actualCommand); Assert.AreEqual(expectedPoint, actualCommand.DeployPoint); Assert.AreEqual(expectedCardinalDirection, actualCommand.DeployDirection); }
void CreateTileInDirection(CardinalDirection direction, int x, int y) { Vector3 position = tileGridBuilder.GetTileWorldPosition(x, y, tileGridManager.tileWidth, tileGridManager.tileHeight, tileGridManager.rowPadding, tileGridManager.columnPadding, transform.position); switch (direction) { case CardinalDirection.Up: position.y += tileGridManager.GridHeight / Globals.Instance.pixelsToUnits; break; case CardinalDirection.Down: position.y -= tileGridManager.GridHeight / Globals.Instance.pixelsToUnits; break; case CardinalDirection.Left: position.x -= tileGridManager.GridWidth / Globals.Instance.pixelsToUnits; break; case CardinalDirection.Right: position.x += tileGridManager.GridWidth / Globals.Instance.pixelsToUnits; break; default: break; } Tile tile = tileGridBuilder.BuildTile(tileGridManager.tilePrefab, tileGridManager.tileWidth, tileGridManager.tileHeight, position); tile.Color = colorManager.RandomColor(); tileGridManager.SetTileAt(x, y, tile); Vector3 targetPosition = tileGridManager.GetTileWorldPosition(x, y); tileAnimationManager.MoveTile(tile, targetPosition, 10.0f, iTween.EaseType.easeInCirc); }
public void GivenTheRoverStartsAtPositionXyFacing(int x, int y, CardinalDirection direction) { _roverPosition = new Position(direction, new Coordinates(x, y)); }
public void Given_size_and_direction_exposes_as_public_properties(int expectedX, int expectedY, CardinalDirection expectedDirection) { var expectedPoint = new Point(expectedX, expectedY); var roverDeployCommand = new RoverDeployCommand(expectedPoint, expectedDirection); Assert.AreEqual(expectedPoint, roverDeployCommand.DeployPoint); Assert.AreEqual(expectedDirection, roverDeployCommand.DeployDirection); }
private AIBoardNode GetNextNode(int row, int column, CardinalDirection direction) { if (row > 5) throw new ArgumentOutOfRangeException(row.ToString()); if (column > 5) throw new ArgumentOutOfRangeException(column.ToString()); int rowIncrement = 0; int columnIncrement = 0; int currentRow = row; int currentColumn = column; AIBoardNode nextNode = TileBoard[row, column]; switch (direction) { case CardinalDirection.North: rowIncrement = -1; break; case CardinalDirection.South: rowIncrement = 1; break; case CardinalDirection.East: columnIncrement = 1; break; case CardinalDirection.West: columnIncrement = -1; break; default: throw new ArgumentOutOfRangeException("Only pass North, South, East or West."); } do { if ((currentRow + rowIncrement) == -1) { currentRow = _tileRows - 1; } else { currentRow = (currentRow + rowIncrement) % _tileRows; } if ((currentColumn + columnIncrement) == -1) { currentColumn = _tileRows - 1; } else { currentColumn = (currentColumn + columnIncrement) % _tileRows; } nextNode = (TileBoard[currentRow, currentColumn].Color == nextNode.Color) ? TileBoard[currentRow, currentColumn] : nextNode; } while (nextNode != TileBoard[currentRow, currentColumn]); return nextNode; }
public static bool AreOrthogonal(CardinalDirection c1, CardinalDirection c2) { return (int)c1 + (int)c2 != 0; }
public static Vector3 ToVector3(this CardinalDirection d) { return(d.GetTileVector().ToVector3()); }
public RoverDeployCommand(MovementPoints aPoint, CardinalDirection aDirection) { DeployPoint = aPoint; DeployDirection = aDirection; }
public CellNeighbour GetNeighbour(CardinalDirection direction) { return(GetNeighbour(CardinalDirectionHelper.ToIndex(direction))); }
public Spell(TileVector pos, CardinalDirection dir, IEnumerable <Plantable> plantableArea) { Pos = pos; Dir = dir; PlantableArea = plantableArea; }
public Character(Position position, CardinalDirection cardinalDirection) : base(position, cardinalDirection) { }
public static CardinalDirection GetNewCardinalDirection(CardinalDirection cardinalDirection, Direction direction) { return((CardinalDirection)(((int)cardinalDirection + (int)direction) % 4)); }
public static string ToCardinalDirectionString(this CardinalDirection move) { return(((char)move).ToString().ToLower()); }
public Position(CardinalDirection cardinalDirection, Coordinates coordinates) { CardinalDirection = cardinalDirection; Coordinates = coordinates; }
public RoverDeployCommand(Position aPosition, CardinalDirection aDirection) { DeploymentPosition = aPosition; DeployDirection = aDirection; }
// RELATIVE DIRECTION UTLITIES - use these where possible /// <summary> /// Find a direction relative to this one, using a RelativeDirection /// eg: North.Turn(ForwardRight) = Northeast /// Southwest.Turn(BackLeft) = Southeast /// </summary> /// <param name="facing">the initial, forward-pointing direction</param> /// <param name="relative">a relative direction to be applied to it</param> /// <returns>the CardinalDirection that is 'relative' to 'facing'</returns> public static CardinalDirection Turn(this CardinalDirection facing, RelativeDirection relative) { return(facing.ArcClockwise((int)relative)); }
public void SetNeighbourCell(CardinalDirection direction, Cell cell) { index_Neighbour[CardinalDirectionHelper.ToIndex(direction)].cell = cell; }
/// <summary> /// Find the relative direction of this direction to another. Specifically, the other /// direction relative to this one. /// note: for two directions A and B: /// A.Turn(A.Cross(B)) = B /// </summary> /// <param name="facing">the direction for other to be found relative </param> /// <param name="other">an other direction</param> /// <returns>'other' relative to 'facing'</returns> public static RelativeDirection Cross(this CardinalDirection facing, CardinalDirection other) { return((RelativeDirection)facing.GetArcLinear(other)); }
public static float GetAngleByCardinalDirection(CardinalDirection cardinalDirection) { return (int)cardinalDirection * 90f; }
public GeoPoint(Double latitude, CardinalDirection latitudeDirection, Double longitude, CardinalDirection longitudeDirection) { m_Latitude = latitude; m_Longitude = longitude; m_LatitudeCD = latitudeDirection; m_LongitudeCD = longitudeDirection; m_Precision = EarthGeo.GeoPrecision; }
public bool HasNeighbour(CardinalDirection direction) { return(HasNeighbourCell(CardinalDirectionHelper.ToIndex(direction))); }
public Wall(ICell parentCell, CardinalDirection orientation) : this(parentCell, null, orientation) { }
/// <summary> /// Determines whether the specified direction is vurnable. /// </summary> /// <param name="direction">The direction.</param> /// <returns></returns> /// <exception cref="System.ArgumentOutOfRangeException">direction;Not a valid value.</exception> public bool IsVurnable(CardinalDirection direction) { switch (direction) { case CardinalDirection.North: case CardinalDirection.South: return (Vurnable & Vurnability.NorthSouth) == Vurnability.NorthSouth; case CardinalDirection.East: case CardinalDirection.West: return (Vurnable & Vurnability.EastWest) == Vurnability.EastWest; default: throw new ArgumentOutOfRangeException("direction", direction, "Not a valid value."); } }
public static Direction GetDirection(CardinalDirection current, CardinalDirection next) { return (Direction)((4 + ((int)next - (int)current)) % 4); }
public Wall(ICell parentCell, GameObject gameObject, CardinalDirection orientation) : base(parentCell, gameObject) { this.Orientation = orientation; CalculateOffset(); }
/// <summary> /// Constructs a new Board and places it in the world at the specified origin and configuration. /// </summary> /// <param name="origin"></param> /// <param name="facing"></param> /// <param name="size"></param> protected Entity(Vector origin, CardinalDirection facing, Vector size = null) { SetPosition(origin); SetOrientation(facing); SetScale(size ?? new Vector()); }
public void UpdateSprite() { // before updating, we'll need to roll sprites, if we haven't already if (doReroll || IsUnrolled()) { foreach (Quadrant quadrant in quadrants) { quadrant.rolledSprite_center = RolledSprite(sprites_center); quadrant.rolledSprite_side = RolledSprite(sprites_side); quadrant.rolledSprite_cornerConvex = RolledSprite(sprites_cornerConvex); quadrant.rolledSprite_cornerConcave = RolledSprite(sprites_cornerConcave); } doReroll = false; } // we've listed our enums in order, so that we can just add or subtract to get the next around the cycle System.Array dirs = System.Enum.GetValues(typeof(CardinalDirection)); CardinalDirection first = (CardinalDirection)dirs.GetValue(0); CardinalDirection last = (CardinalDirection)dirs.GetValue(dirs.Length - 1); // each SpriteRenderer's gonna have a different rotation/Sprite, depending on which neighbors exist foreach (Quadrant quadrant in quadrants) { Sprite sprite = null; CardinalDirection dir = quadrant.dir; CardinalDirection dirCCW = dir.Equals(last) ? first : dir + 1; CardinalDirection dirCW = dir.Equals(first) ? last : dir - 1; float rot = quadrant.startRot; if (HasNeighbor(dirCW) && HasNeighbor(dirCCW)) { if (HasNeighbor(dir)) { sprite = quadrant.rolledSprite_center; rot = 0f; } else { sprite = quadrant.rolledSprite_cornerConcave; } } else if (!HasNeighbor(dirCW) && !HasNeighbor(dirCCW)) { sprite = quadrant.rolledSprite_cornerConvex; } else { sprite = quadrant.rolledSprite_side; if (HasNeighbor(dirCW)) { rot += 90; } } quadrant.sr.sprite = sprite; quadrant.sr.transform.rotation = Quaternion.Euler(0, 0, rot); } }
public static List <Spell> Invoke(Stage stage, TileVector pos, CardinalDirection dir) { var map = stage.ToDictionary(); var history = new List <Spell>(); HashSet <Plantable> currentPlantableArea = null; while (map.ContainsKey(pos)) { var space = map[pos]; if (currentPlantableArea == null) { if (space.Plantable != null && space.Plantable.State == PlantableState.Vacant) { currentPlantableArea = new HashSet <Plantable>(); var fringe = new Queue <TileVector>(); fringe.Enqueue(pos); while (fringe.Count > 0) // find all adjacent plantables. { var fringePos = fringe.Dequeue(); if (!map.ContainsKey(fringePos)) { continue; } var plantable = map[fringePos].Plantable; if (plantable == null || currentPlantableArea.Contains(plantable)) { continue; } currentPlantableArea.Add(plantable); foreach (var adj in fringePos.Adjacent()) { fringe.Enqueue(adj); } } } } else if (!currentPlantableArea.Contains(space.Plantable)) // stepped out of the plant area { bool solved = currentPlantableArea.All(p => { var plant = map[p.TilePos].Occupant as Plant; return(plant != null && plant.Hits > 0); }); foreach (var plantable in currentPlantableArea) { plantable.State = solved ? PlantableState.Solved : PlantableState.Imbued; } currentPlantableArea = null; } var spell = new Spell(pos, dir, currentPlantableArea); // record this frame of the spell invocation history.Add(spell); if (space.HasTile && !space.Tile.BlockSpell) // advance spell { var plant = space.Occupant as Plant; if (plant != null) { spell.Plant = plant; // add plant to record, for convinience switch (plant.Type) // trigger plant side effects { case PlantType.Twist: dir = dir.ArcClockwise(1); break; } if (currentPlantableArea != null) // implies this area is being activated by this current spell { plant.Hits += 1; // make plant grow } } pos = pos + dir; } else { if (currentPlantableArea != null) { foreach (var plantable in currentPlantableArea) { plantable.State = PlantableState.Imbued; } } break; // end the spell invocation } } return(history); }
private void SetInstruction(NavigationInstruction instruction, out string stepLabel, out string stepImage, out string firstDirectionImage, out int rotation, out int location, out int instructionValue) { var currentLanguage = CrossMultilingual.Current.CurrentCultureInfo; string connectionTypeString = ""; string nextWaypointName = instruction._nextWaypointName; nextWaypointName = _xmlInformation.GiveWaypointName(instruction._nextWaypointGuid); string nextRegionName = instruction._information._regionName; firstDirectionImage = null; rotation = 0; stepImage = ""; instructionValue = _originalInstructionScale; location = _originalInstructionLocation; nextRegionName = _xmlInformation.GiveRegionName(instruction._nextRegionGuid); switch (instruction._information._turnDirection) { case TurnDirection.FirstDirection: string firstDirection_Landmark = _firstDirectionInstruction.returnLandmark(instruction._currentWaypointGuid); CardinalDirection firstDirection_Direction = _firstDirectionInstruction.returnDirection(instruction._currentWaypointGuid); int faceDirection = (int)firstDirection_Direction; int turnDirection = (int)instruction._information._relatedDirectionOfFirstDirection; string initialDirectionString = ""; int directionFaceorBack = _firstDirectionInstruction.returnFaceOrBack(instruction._currentWaypointGuid); if (faceDirection > turnDirection) { turnDirection = (turnDirection + 8) - faceDirection; } else { turnDirection = turnDirection - faceDirection; } if (directionFaceorBack == _initialFaceDirection) { initialDirectionString = _resourceManager.GetString( "DIRECTION_INITIAIL_FACE_STRING", currentLanguage); } else if (directionFaceorBack == _initialBackDirection) { initialDirectionString = _resourceManager.GetString( "DIRECTION_INITIAIL_BACK_STRING", currentLanguage); if (turnDirection < 4) { turnDirection = turnDirection + 4; } else if (turnDirection >= 4) { turnDirection = turnDirection - 4; } } string instructionDirection = ""; string stepImageString = ""; CardinalDirection cardinalDirection = (CardinalDirection)turnDirection; switch (cardinalDirection) { case CardinalDirection.North: instructionDirection = _resourceManager.GetString( "GO_STRAIGHT_STRING", currentLanguage); stepImageString = "Arrow_up"; break; case CardinalDirection.Northeast: instructionDirection = _resourceManager.GetString( "GO_RIGHT_FRONT_STRING", currentLanguage); stepImageString = "Arrow_frontright"; break; case CardinalDirection.East: instructionDirection = _resourceManager.GetString( "TURN_RIGHT_STRING", currentLanguage); stepImageString = "Arrow_right"; break; case CardinalDirection.Southeast: instructionDirection = _resourceManager.GetString( "TURN_RIGHT_REAR_STRING", currentLanguage); stepImageString = "Arrow_rearright"; break; case CardinalDirection.South: instructionDirection = _resourceManager.GetString( "TURN_BACK_STRING", currentLanguage); stepImageString = "Arrow_down"; break; case CardinalDirection.Southwest: instructionDirection = _resourceManager.GetString( "TURN_RIGHT_REAR_STRING", currentLanguage); stepImageString = "Arrow_rearleft"; break; case CardinalDirection.West: instructionDirection = _resourceManager.GetString( "TURN_LEFT_STRING", currentLanguage); stepImageString = "Arrow_left"; break; case CardinalDirection.Northwest: instructionDirection = _resourceManager.GetString( "TURN_LEFT_FRONT_STRING", currentLanguage); stepImageString = "Arrow_frontleft"; break; } if (instruction._previousRegionGuid != Guid.Empty && instruction._previousRegionGuid != instruction._currentRegionGuid) { stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_INITIAIL_CROSS_REGION_STRING", currentLanguage), instructionDirection, Environment.NewLine, nextWaypointName, Environment.NewLine, instruction._information._distance); stepImage = stepImageString; break; } else if (firstDirection_Landmark == _pictureType) { string pictureName; string regionString = instruction._currentRegionGuid.ToString(); string waypointString = instruction._currentWaypointGuid.ToString(); pictureName = _navigationGraph.GetBuildingName() + regionString.Substring(33, 3) + waypointString.Substring(31, 5); stepLabel = string.Format( initialDirectionString, _resourceManager.GetString( "PICTURE_DIRECTION_STRING", currentLanguage), Environment.NewLine, instructionDirection, Environment.NewLine, nextWaypointName, " ", instruction._information._distance); firstDirectionImage = pictureName; stepImage = stepImageString; rotation = 75; location = _firstDirectionInstructionLocation; instructionValue = _firstDirectionInstructionScale; break; } else { stepLabel = string.Format( initialDirectionString, firstDirection_Landmark, Environment.NewLine, instructionDirection, Environment.NewLine, nextWaypointName, Environment.NewLine, instruction._information._distance); stepImage = stepImageString; break; } case TurnDirection.Forward: stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_STRAIGHT_STRING", currentLanguage), Environment.NewLine, instruction._information._distance, Environment.NewLine, nextWaypointName); stepImage = "Arrow_up"; break; case TurnDirection.Forward_Right: stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_RIGHT_FRONT_STRING", currentLanguage), Environment.NewLine, instruction._information._distance, Environment.NewLine, nextWaypointName); stepImage = "Arrow_frontright"; break; case TurnDirection.Right: stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_RIGHT_STRING", currentLanguage), Environment.NewLine, instruction._information._distance, Environment.NewLine, nextWaypointName); stepImage = "Arrow_right"; break; case TurnDirection.Backward_Right: stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_RIGHT_REAR_STRING", currentLanguage), Environment.NewLine, instruction._information._distance, Environment.NewLine, nextWaypointName); stepImage = "Arrow_rearright"; break; case TurnDirection.Backward: stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_REAR_STRING", currentLanguage), Environment.NewLine, instruction._information._distance, Environment.NewLine, nextWaypointName); stepImage = "Arrow_down"; break; case TurnDirection.Backward_Left: stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_LEFT_REAR_STRING", currentLanguage), Environment.NewLine, instruction._information._distance, Environment.NewLine, nextWaypointName); stepImage = "Arrow_rearleft"; break; case TurnDirection.Left: stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_LEFT_STRING", currentLanguage), Environment.NewLine, instruction._information._distance, Environment.NewLine, nextWaypointName); stepImage = "Arrow_left"; break; case TurnDirection.Forward_Left: stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_LEFT_FRONT_STRING", currentLanguage), Environment.NewLine, instruction._information._distance, Environment.NewLine, nextWaypointName); stepImage = "Arrow_frontleft"; break; case TurnDirection.Up: switch (instruction._information._connectionType) { case ConnectionType.Elevator: connectionTypeString = _resourceManager.GetString("ELEVATOR_STRING", currentLanguage); stepImage = "Elevator_up"; break; case ConnectionType.Escalator: connectionTypeString = _resourceManager.GetString("ESCALATOR_STRING", currentLanguage); stepImage = "Stairs_up"; break; case ConnectionType.Stair: connectionTypeString = _resourceManager.GetString("STAIR_STRING", currentLanguage); stepImage = "Stairs_up"; break; case ConnectionType.NormalHallway: connectionTypeString = _resourceManager.GetString("NORMALHALLWAY_STRING", currentLanguage); stepImage = "Stairs_up"; break; } stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_UP_STRING", currentLanguage), connectionTypeString, Environment.NewLine, nextRegionName); break; case TurnDirection.Down: switch (instruction._information._connectionType) { case ConnectionType.Elevator: connectionTypeString = _resourceManager.GetString("ELEVATOR_STRING", currentLanguage); stepImage = "Elevtor_down"; break; case ConnectionType.Escalator: connectionTypeString = _resourceManager.GetString("ESCALATOR_STRING", currentLanguage); stepImage = "Stairs_down"; break; case ConnectionType.Stair: connectionTypeString = _resourceManager.GetString("STAIR_STRING", currentLanguage); stepImage = "Stairs_down"; break; case ConnectionType.NormalHallway: connectionTypeString = _resourceManager.GetString("NORMALHALLWAY_STRING", currentLanguage); stepImage = "Stairs_down"; break; } stepLabel = string.Format( _resourceManager.GetString( "DIRECTION_DOWN_STRING", currentLanguage), connectionTypeString, Environment.NewLine, nextRegionName); break; default: stepLabel = "You're get ERROR status"; stepImage = "Warning"; break; } }
public static Vector2I ToVector(this CardinalDirection cardinal) { return(vectors[(int)cardinal]); }
// ARC UTILITIES - use these when you need to numerically quantify rotation /// <summary> /// Find the direction specified by rotating this direction a number of 30 degree steps, clockwise. /// </summary> /// <param name="d">direction to start from</param> /// <param name="steps">number of 30 degree steps to rotate, clockwise</param> /// <returns>a new direction</returns> public static CardinalDirection ArcClockwise(this CardinalDirection d, int steps) { return((CardinalDirection)Wrap((int)d + steps)); }
public static bool AreOpposite(CardinalDirection c1, CardinalDirection c2) { return (int)c1 + (int)c2 == 0; }
/// <summary> /// Get the number of arc steps, in clockwise direction, from this CardinalDirection to another. /// </summary> /// <param name="facing">original direction</param> /// <param name="to">number of 30 degree steps to rotate it by</param> /// <returns>an int between 0 and 5 (inclusive)</returns> public static int GetArcLinear(this CardinalDirection facing, CardinalDirection to) { return(Wrap((int)to - (int)facing)); }
public static LinkDirection GetClosestDirectionPoints(LinkDrawing linkDrawing) { ILinkableDrawing destinationDrawing = linkDrawing.DestinationDrawing; ILinkableDrawing sourceDrawing = linkDrawing.SourceDrawing; CardinalDirection[] directionsArray = new CardinalDirection[] { CardinalDirection.North, CardinalDirection.South, CardinalDirection.West, CardinalDirection.East }; List<CardinalDirection> directions = new List<CardinalDirection>(directionsArray); CardinalDirection from = CardinalDirection.None; CardinalDirection to = CardinalDirection.None; if (destinationDrawing.LinkAttachMode == LinkAttachMode.LEFT_RIGHT) { if (destinationDrawing.Location.X > sourceDrawing.Location.X + sourceDrawing.Size.Width / 2) { to = CardinalDirection.West; } else { to = CardinalDirection.East; } } else if (destinationDrawing.LinkAttachMode == LinkAttachMode.ALL) { if (destinationDrawing.Location.Y > sourceDrawing.Location.Y + sourceDrawing.Size.Height) { to = CardinalDirection.South; } else if (destinationDrawing.Location.Y + destinationDrawing.Size.Height < sourceDrawing.Location.Y) { to = CardinalDirection.North; } else if (destinationDrawing.Location.X > sourceDrawing.Location.X + sourceDrawing.Size.Width) { to = CardinalDirection.East; } else if (destinationDrawing.Location.X + destinationDrawing.Size.Width < sourceDrawing.Location.X) { to = CardinalDirection.West; } } if (sourceDrawing.LinkAttachMode == LinkAttachMode.ALL) { if (sourceDrawing.Location.Y > destinationDrawing.Location.Y + destinationDrawing.Size.Height) { from = CardinalDirection.South; } else if (sourceDrawing.Location.Y + sourceDrawing.Size.Height < destinationDrawing.Location.Y) { from = CardinalDirection.North; } else if (sourceDrawing.Location.X > destinationDrawing.Location.X + destinationDrawing.Size.Width) { from = CardinalDirection.East; } else if (sourceDrawing.Location.X + sourceDrawing.Size.Width < destinationDrawing.Location.X) { from = CardinalDirection.West; } } else if (sourceDrawing.LinkAttachMode == LinkAttachMode.LEFT_RIGHT) { if (sourceDrawing.Location.X > destinationDrawing.Location.X + destinationDrawing.Size.Width / 2) { from = CardinalDirection.East; } else { from = CardinalDirection.West; } } return new LinkDirection(from, to); }
public static int GetBearing(this CardinalDirection d) { return((int)d * 60); }
public static Direction GetDirection(CardinalDirection current, CardinalDirection next) { return((Direction)((4 + ((int)next - (int)current)) % 4)); }
public Vector2i GetGridNeighbourGridPosition(Vector2i gridPosition, CardinalDirection direction) { return(GetGridNeighbourGridPosition(gridPosition, CardinalDirectionHelper.ToIndex(direction))); }
public LinkDirection(CardinalDirection from, CardinalDirection to) { this.from = from; this.to = to; }
public static float GetAngleByCardinalDirection(CardinalDirection cardinalDirection) { return((int)cardinalDirection * 90f); }
/// <summary> /// Moves the Santa-type figure in the specified direction. /// </summary> /// <param name="direction">The direction to move in.</param> /// <exception cref="ArgumentOutOfRangeException"><paramref name="direction"/> is invalid.</exception> internal void Move(CardinalDirection direction) { switch (direction) { case CardinalDirection.East: Location += new Size(1, 0); break; case CardinalDirection.North: Location += new Size(0, 1); break; case CardinalDirection.South: Location += new Size(0, -1); break; case CardinalDirection.West: Location += new Size(-1, 0); break; default: throw new ArgumentOutOfRangeException(nameof(direction), direction, "The specified direction is invalid."); } }
public GeoLine(double degrees, double minutes, double seconds, GeoLineType lineType, CardinalDirection cardinalDirection) { if (lineType == GeoLineType.Latitude) { MaxDegrees = 90; } else { MaxDegrees = 180; } if (degrees < 0 && lineType == GeoLineType.Longitude && cardinalDirection == CardinalDirection.W) { throw new ArgumentException("A negative Longitude can only represent Eastern Meridians."); } if (degrees < 0 && lineType == GeoLineType.Latitude && cardinalDirection == CardinalDirection.N) { throw new ArgumentException("A negative Latitude can only represent Southern Parallels."); } if (lineType == GeoLineType.Latitude && (cardinalDirection == CardinalDirection.E || cardinalDirection == CardinalDirection.W)) { throw new ArgumentException("Latitude only measures location relative to North and South."); } if (lineType == GeoLineType.Longitude && (cardinalDirection == CardinalDirection.N || cardinalDirection == CardinalDirection.S)) { throw new ArgumentException("Longitude only measures location relative to East and West."); } if (Math.Abs(degrees) > Math.Abs(MaxDegrees)) { throw new ArgumentException("Absolute Value of the measurement cannot be greater than the max"); } Degrees = Math.Abs(degrees); Minutes = Math.Abs(minutes); Seconds = Math.Abs(seconds); CardinalDirection = cardinalDirection; }