public Move(Piece promoteTo, Coordinate from, Coordinate to)
 {
     m_moveType = MoveType.Promotion;
     m_promoteTo = promoteTo;
     m_from = from;
     m_to = to;
 }

        public ActionResult PlayAgainstFriend(MoveType moveOne, MoveType moveTwo, MoveType moveThree, Guid roundId)
        {
            // Play moves
            _bus.Send(new PlayMoves(Player.Id, roundId, moveOne, moveTwo, moveThree));

            return RedirectToAction("PlaySummary", "Player");
        }

 public void PrepareForLanding(Vector2 landPosition, Vector2 planetPosition)
 {
     var method = new LandingMove (landPosition, planetPosition);
     method.Landed += MoveOnPlanet;
     actualMethod = method;
     type = MoveType.Landing;
 }

 public void ToggleMoveType()
 {
     if (moveType == MoveType.MOVE_POSITION)
         moveType = MoveType.NONE;
     else
         moveType = MoveType.MOVE_POSITION;
 }

 public StateTypeSet(StateSystem statesystem, String label, TextSection textsection)
     : base(statesystem, label, textsection)
 {
     m_statetype = textsection.GetAttribute<StateType>("statetype", StateType.Unchanged);
     m_movetype = textsection.GetAttribute<MoveType>("movetype", MoveType.Unchanged);
     m_physics = textsection.GetAttribute<Physics>("Physics", Physics.Unchanged);
 }

        public CollisionType EvaluateNextMove(MoveType move, IFigure figure)
        {
            var collision = CollisionType.None;
            IFigure movedFigure;
            switch (move)
            {
                case MoveType.RowAdded:
                    collision = ResolveRowAdded();
                    break;
                case MoveType.MoveRight:
                    movedFigure = figure.MoveRight();
                    collision = ResolveMoveRight(movedFigure);
                    break;
                case MoveType.MoveLeft:
                    movedFigure = figure.MoveLeft();
                    collision = ResolveMoveLeft(movedFigure);
                    break;
                case MoveType.MoveDown:
                    movedFigure = figure.MoveDown();
                    collision = ResolveMoveDown(movedFigure);
                    break;
                case MoveType.TossDown:
                    // for now do nothing
                    break;
                case MoveType.Rotate:
                    var rotatedFigure = figure.RotateClockwise();
                    collision = ResolveRotate(rotatedFigure);
                    break;
                default:
                    throw new NotImplementedException("unknown movement type: " + move);
            }

            return collision;
        }

 //determine the outcome of the current move action
 void CheckProbabilities()
 {
     switch (movementType) {
     case MoveType.HORIZONTAL: {
         if (Random.value < probabilities.horizontal * indicatorMultiplier) {
             MoveLandSlide(-1);
         } else {
             movementType = MoveType.NONE;
             //probabilities.horizontal += 0.1f;
             //probabilities.vertical /= 1.5f;
         }
         break;
     }
     case MoveType.VERTICAL: {
         if (Random.value < probabilities.vertical * indicatorMultiplier) {
             MoveLandSlide(-2);
         } else {
             movementType = MoveType.NONE;
             probabilities.horizontal *= additionalLandSlideChance_vertical;
             probabilities.vertical *= additionalLandSlideChance_vertical;
         }
         break;
     }
     case MoveType.LANDSLIDE: {
         movementType = MoveType.NONE;
         ResetProbabilities();
         break;
         }
     }
 }

        public Ball(Color color, PointF point, float jumpSpeed, float radius, Frame frame, Direction direction)
        {
            this.pen = new Pen(color);
            this.frame = frame;
            this.x = point.X;
            this.y = point.Y;
            this.jumpSpeed = jumpSpeed;
            this.radius = radius;

            switch (direction)
            {
                case Direction.DOWN:
                    xmt = MoveType.Down;
                    ymt = MoveType.Down;
                    break;
                case Direction.LEFT:
                    xmt = MoveType.Up;
                    ymt = MoveType.Down;
                    break;
                case Direction.RIGHT:
                    xmt = MoveType.Down;
                    ymt = MoveType.Up;
                    break;
                case Direction.UP:
                    xmt = MoveType.Up;
                    ymt = MoveType.Up;
                    break;
            }
        }

 public bool CheckLastMove([NotNull] IList<MoveType> moves, MoveType lastMove)
 {
     if (lastMove == MoveType.NW || lastMove == MoveType.NE)
         return false;
     if (lastMove == MoveType.SW || lastMove == MoveType.SE)
         return true;
     if (symmetric == 1)
     {
         if (lastMove == MoveType.RotateCCW || lastMove == MoveType.RotateCW)
             return false;
         var prevMove = moves.Any() ? moves.Last() : (MoveType?)null;
         if (lastMove == MoveType.E && prevMove == MoveType.W)
             return false;
         if (lastMove == MoveType.W && prevMove == MoveType.E)
             return false;
         return true;
     }
     var used = new HashSet<Tuple<int, int>>();
     var position = Tuple.Create(0, 0);
     used.Add(position);
     position = ApplyMove(lastMove, position);
     if (position == null)
         throw new InvalidOperationException("Position couldn't be null here");
     used.Add(position);
     for (var i = moves.Count - 1; i >= 0; i--)
     {
         position = ApplyMove(moves[i], position);
         if (position == null)
             return true;
         if (!used.Add(position))
             return false;
     }
     return true;
 }

 public Vector(MoveType move, int y, int length = 1)
 {
     switch (move)
     {
         case MoveType.E:
             X = length;
             break;
         case MoveType.W:
             X = -length;
             break;
         case MoveType.SW:
             Y = length;
             X = GetWestDX(y, length);
             break;
         case MoveType.SE:
             Y = length;
             X = GetEastDX(y, length);
             break;
         case MoveType.NW:
             Y = -length;
             X = GetWestDX(y, length);
             break;
         case MoveType.NE:
             Y = -length;
             X = GetEastDX(y, length);
             break;
         default:
             throw new ArgumentOutOfRangeException(move.ToString(), move, null);
     }
 }

 public bool isWall(MoveType type)
 {
     bool collide = false;
     switch (type)
     {
         case MoveType.Down:
             if (point.Y > GameConsole.Height)
             {
                 collide = true;
             }
             break;
         case MoveType.Up:
             if (point.Y >= 0){
                 collide = true;
             }
             break;
         case MoveType.Left:
             if (point.X <= 0 )
             {
                 collide = true;
             }
             break;
         case MoveType.Right:
             if (point.X > GameConsole.Width)
             {
                 collide = true;
             }
             break;
     }
     return collide;
 }

        public void HandleInput(float dt)
        {
            float mvSpd = walkSpeed;

            if (myController.Sprint.Down && (currentMoveType == MoveType.RUN || currentMoveType == MoveType.WALK))
            {
                currentMoveType = MoveType.RUN;
                mvSpd = runSpeed;
            }
            else if (currentMoveType == MoveType.RUN)
            {
                currentMoveType = MoveType.WALK;
            }

            if (Math.Abs(myController.Movement.X) > 0.1f)
            {
                myMotion.X = myController.Movement.X * mvSpd;
            }
            else
            {
                myMotion.X = 0.0f;
            }

            if (Math.Abs(myController.Movement.Y) > 0.1f)
            {
                myMotion.Y = myController.Movement.Y * mvSpd;
            }
            else
            {
                myMotion.Y = 0.0f;
            }
        }

 public PageData(int pageLevel, Genre pageGenre, MoveType pageType, bool isRare)
 {
     m_pageLevel = pageLevel;
     m_pageGenre = pageGenre;
     m_pageType = pageType;
     m_isRare = isRare;
     m_inventoryId = -1;
 }

    public void MoveOnPlanet(Vector2 planetPosition)
    {
        if (actualMethod is LandingMove)
            (actualMethod as LandingMove).Landed -= MoveOnPlanet;

        actualMethod = new LandMove (planetPosition);
        type = MoveType.LandMove;
    }

 public Move(int Piece, Position StartPosition, Position EndPosition, MoveType Type, Position MiddlePosition = Position.None)
 {
     this.Piece = Piece;
     this.StartPosition = StartPosition;
     this.EndPosition = EndPosition;
     this.MiddlePosition = MiddlePosition;
     this.Type = Type;
 }

        public MoveResult(MoveType type, CheckersPiece piece, int nx, int ny)
        {
            Type = type;
            OriginalPieceLocation = new Location(piece.X, piece.Y);
            FinalPieceLocation = new Location(nx, ny);

            JumpResults = new List<JumpResult>();
        }

    internal void Move(MoveType type, TileController start, TileController stop) {
        string moveType = type == MoveType.Empty
            ? "MoveToEmpty"
            : type == MoveType.Merge ? "MoveToMerge" : type == MoveType.Attack ? "MoveToAttack" : "";

        _tcpClient.Send(string.Format("[Notify:{0}:{1}|({2}:{3})|({4}:{5})]", moveType, _guid, start.Position.x,
            start.Position.y, stop.Position.x, stop.Position.y));
    }

        /// <summary>
        /// Log a game move to the logging session
        /// </summary>
        /// <param name="player"></param>
        /// <param name="timeOfMove"></param>
        /// <param name="moveType"></param>
        public void LogMove(string player, int timeOfMove, MoveType moveType)
        {
            if (_gameData == null)
            {
                throw new InvalidOperationException("The logging session has not begun. Unable to log move.");
            }

            _gameData.AddGameMoveDataPoint(player, timeOfMove, moveType);
        }

        public bool MoveWon(MoveType move1, MoveType move2)
        {
            if ((move1 == MoveType.Punch && move2 == MoveType.Block) ||
                (move1 == MoveType.Kick && move2 == MoveType.Punch) ||
                (move1 == MoveType.Block && move2 == MoveType.Kick))
                return true;

            return false;
        }

 private CoordCmd(double? x, double? y, double? z, double? a, MoveType type)
 {
     Contract.Assert(x.HasValue || y.HasValue || z.HasValue || a.HasValue);
     X = x;
     Y = y;
     Z = z;
     A = a;
     Type = type;
 }