public bool Rotate(Rotation rotation)
 {
     int deltaX, deltaY;
     Deck head = Decks.First();
     if (IsShipRotatable())
     {
         GetRotationDirection(out deltaY, out deltaX);
         for (int i = 1; i < Decks.Count; i++)
         {
             int newX = 0, newY = 0;
             switch (rotation)
             {
                 case Rotation.Left:
                     newX = head.X - deltaX * i;
                     newY = head.Y - deltaY * i;
                     break;
                 case Rotation.Right:
                     newX = head.X + deltaX * i;
                     newY = head.Y + deltaY * i;
                     break;
             }
             if (AreCoordinatesNotNegative(newX, newY))
             {
                 Decks.ElementAt(i).X = newX;
                 Decks.ElementAt(i).Y = newY;
             }
             else
             {
                 return false;
             }
         }
     }
     return true;
 }

 static Rotation CreateRotation()
 {
     var rotation = new Rotation { Id = 2, Name = "TheRotation", RotationType = RotationTypes.Rotation1 };
       var startTime = new DateTime(1, 1, 1, 7, 0, 0);
       rotation.RotationShifts.Add(new RotationShift(TimeConstants.Weekday, startTime, startTime.AddHours(12).AddMinutes(-1)));
       return rotation;
 }

 public override void FromReader(IMinecraftDataReader reader)
 {
     Rotation = new Rotation(
         reader.ReadFloat(), 
         reader.ReadFloat(), 
         reader.ReadFloat());
 }

 public void CanTurn(Rotation rotation)
 {
     var ant = new Ant(_initialDirection, _initialPosition);
     var expectedDirection = _initialDirection.Rotate(rotation);
     ant.Turn(rotation);
     ant.Direction.Should().Be(expectedDirection);
 }

        public ShipInstance(Position pos, Rotation r, Ship ship)
        {
            this.pos = pos;
            this.rotation = r;
            this.ship = ship;

            this.sunken = false;
        }

 public static void ReversePath(Rotation[] path)
 {
     for (int i = 0; i < path.Length; i++)
     {
         path[i] = (Rotation)(((byte)path[i] + 2) % 4);
     }
     Array.Reverse(path);
 }

		public X3DViewpoint (float? fieldOfView, Vector3? position, 
		                     Rotation orientation, Vector3? centerOfRotation)
		{
			this.FieldOfView = fieldOfView;
			this.Position = position;
			this.Orientation = orientation;
			this.CenterOfRotation = centerOfRotation;
		}

		public X3DTransform (X3DNode[] nodes,  
			Vector3? translation, 
			Rotation rotatio, 
			Vector3? scale) : base (nodes)
		{
			this.Translation = translation;
			this.Rotation = rotatio;
			this.Scale = scale;
		}

        private void SetRotation(Rotation rotation)
        {
            var prefabRotation = doorPrefab.transform.eulerAngles;

            prefabRotation.y = RotationHelper.GetEulerAngle(rotation);

            this.goReference.transform.eulerAngles = prefabRotation;
            this.rotation = rotation;
        }

 // Use this for initialization
 void Start()
 {
     originalPos = transform.position;
     originalPos.z = 0;
     leashLength = 0.5f;
     moveSpeed = 1.0f;
     playerController = memoizer.GetMemoizedComponent<CharacterController>(gameObject);
     rotateScript = memoizer.GetMemoizedComponent<Rotation>(GameObject.FindGameObjectWithTag("Sphere"));
 }

 public SETItem(EditorItemSelection selectionManager)
     : base(selectionManager)
 {
     Position = new Vertex();
     Rotation = new Rotation();
     Scale = new Vertex();
     objdef = LevelData.ObjDefs[id];
     bounds = objdef.GetBounds(this);
 }

 // Apply a full move to the board
 // This swaps CurrentPlayer
 public bool ApplyMove(int xCoord, int yCoord, PieceColor color, Rotation r)
 {
     bool placed = this.PlacePieceAt(xCoord, yCoord, color);
     if (placed)
     {
         this.DoRotation(r);
         this.CurrentPlayer = (color == PieceColor.White) ? PieceColor.Black : PieceColor.White;
     }
     return placed;
 }

        public float Rotate(Rotation rotation, float _Rotation)
        {
            if (rotation == Rotation.Left)
                return RotateLeft(_Rotation);

            if (rotation == Rotation.Right)
                return RotateRight(_Rotation);

            return 0;
        }

 public Rotation(string name, double roll, double pitch, double yaw)
 {
     self = this;
     self.name = name;
     self.roll = roll;
     self.pitch = pitch;
     self.yaw = yaw;
     self.r = new Matrix3();
     r.from_euler(roll, pitch, yaw);
 }

        private void SpawnDoor(IntVector3 position, Rotation rotation)
        {
            if (this.goReference == null) {
                PreloadPrefabs();

                this.goReference = doorPrefab.Spawn();
                this.goReference.transform.position = position.ToVector3();

                SetRotation(rotation);
            }
        }

        public void GenerateMessage()
        {
            var rotation = new Rotation {
                Id = 1,
                Name = "Name",
                RotationType = RotationTypes.Rotation3
            };
            var rotationMessage = new RotationMessage(rotation);

            ServiceTestHelper.AssertDomainMessageProperties(rotation, rotationMessage);
            Assert.AreEqual(rotation.RotationType, rotationMessage.RotationType);
        }

        public void Test_Rover_Can_Rotate_90_Degrees(Direction startDirection, Rotation rotateDirection, Direction endDirection)
        {
            var startPosition = new Position { Direction = startDirection, X = 0, Y = 0 };
            var rover = new Rover(startPosition);

            rover.Rotate(rotateDirection);

            var newPosition = rover.GetCurrentPosition();
            var expectedPosition = new Position { Direction = endDirection, X = 0, Y = 0 };

            Assert.AreEqual(newPosition, expectedPosition);
        }

 public Direction Rotate(Rotation rotation)
 {
     switch (rotation)
     {
         case Rotation.Left:
             return new Direction(-_dy, _dx);
         case Rotation.Right:
             return new Direction(_dy, -_dx);
         default:
             throw new ArgumentOutOfRangeException("rotation");
     }
 }

        public void Rotate(Rotation direction)
        {
            switch(direction)
            {
                case Rotation.Left:
                    RotateLeft();
                    break;

                case Rotation.Right:
                    RotateRight();
                    break;
            }
        }

        public static Directions Rotate(this Directions direction, Rotation rotation)
        {
            // Counter Clockwise
            if (rotation == Rotation.CounterClockwise)
            {
                switch (direction)
                {
                    default:
                        return Directions.None;
                    case Directions.Up:
                        return Directions.UpperLeft;
                    case Directions.UpperLeft:
                        return Directions.Left;
                    case Directions.Left:
                        return Directions.LowerLeft;
                    case Directions.LowerLeft:
                        return Directions.Down;
                    case Directions.Down:
                        return Directions.LowerRight;
                    case Directions.LowerRight:
                        return Directions.Right;
                    case Directions.Right:
                        return Directions.UpperRight;
                    case Directions.UpperRight:
                        return Directions.Up;
                }
            }

            // Clockwise
            switch (direction)
            {
                default:
                    return Directions.None;
                case Directions.Up:
                    return Directions.UpperRight;
                case Directions.UpperRight:
                    return Directions.Right;
                case Directions.Right:
                    return Directions.LowerRight;
                case Directions.LowerRight:
                    return Directions.Down;
                case Directions.Down:
                    return Directions.LowerLeft;
                case Directions.LowerLeft:
                    return Directions.Left;
                case Directions.Left:
                    return Directions.UpperLeft;
                case Directions.UpperLeft:
                    return Directions.Up;
            }
        }