/// <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;
}
