public Piece(bool[,] _data, PieceType _type, TransFormation _trans, Color _color)
 {
     m_data = _data;
     m_type = _type;
     m_trans = _trans;
     m_color = _color;
 }

 public Square(string nam, int num)
 {
     InitializeComponent();
     // Init Obj Rec
     InitializeDefinitions();
     // Set Square Size
     MyTagVisualizer.Height = squareSize;
     MyTagVisualizer.Width = squareSize;
     // Bring TagVisualizer to the top
     MyTagVisualizer.SetCurrentValue(Panel.ZIndexProperty, 5);
     // Set internal information
     this.name = nam;
     this.number = num;
     this.piece = PieceType.Empty;
     this.Width = squareSize;
     this.Height = squareSize;
     // Set the Square in the middle
     this.SetCurrentValue(Panel.ZIndexProperty, 3);
     // Add the Rectangle Layer
     rectangle.Width = squareSize;
     rectangle.Height = squareSize;
     rectangle.Stroke = Brushes.Black;
     rectangle.StrokeThickness = 1;
     rectangle.Opacity = 0.5;
     colourRectangle(Brushes.Transparent);
 }

 public Piece(int x, int y, PieceType type, bool isBlack)
 {
     _x = x;
     _y = y;
     _type = type;
     _isBlack = isBlack;
 }

 public Piece(PieceType type, Player owner)
 {
     Type = type;
     Owner = owner;
     Hex = null;
     CanMove = true;
 }

 internal ChessPiece(bool white, PieceType type)
 {
     this.white = white;
     this.type = type;
     this.lastMove = 0;
     this.lastSquare = new SquareCoordinates(-1, -1);
 }

 public Piece(PlayerColor playerColor, PieceType pieceType, byte x, byte y)
 {
     playerColorValue = playerColor;
     pieceTypeValue = pieceType;
     xValue = x;
     yValue = y;
 }

 public Piece(string id, string asset, Vector3 position, int colorT, PieceType pieceT)
     : base(id, position)
 {
     _asset = asset;
     ColorType = (Colour)colorT;
     Piece_Type = pieceT;
 }

 public ChessPiece()
 {
     gameObject = null;
     playerSide = PlayerSide.e_NoneSide;
     pieceType = PieceType.e_None;
     piecePlayerType = PiecePlayerType.eNone_Piece;
 }

 public ChessPiece(PieceType pieceType, PieceColour pieceColour, int file, int rank)
 {
     this.pieceType = pieceType;
     this.pieceColour = pieceColour;
     this.rank = rank;
     this.file = file;
 }

        public Piece(PieceType type, PieceColor color, int col, int row, Board board)
        {
            this.Col = col;
            this.Row = row;
            this.X = col * Game.TILESIZE;
            this.Y =  row * Game.TILESIZE;
            this.Color = color;
            this.Board = board;
            FirstMove = true;
            SetType(type);

            this.MouseDown += delegate(object s, MouseButtonEventArgs ev) {
                if (!Game.GameOver && ((!Game.IsConnected && Game.MyTurn(Color)) ||
                    (Game.IsConnected && Game.MainColor == Color && Game.MyTurn())))
                {
                    dragging = true;
                    this.Cursor = Cursors.Hand;
                    System.Windows.Controls.Canvas.SetZIndex(this, 1000);
                }
            };

            this.MouseUp += new MouseButtonEventHandler(image_MouseUp);

            this.MouseMove += new MouseEventHandler(image_MouseMove);

            this.MouseLeave += new MouseEventHandler(image_MouseMove);
        }

        /// <summary>
        /// Instantiate <see cref="Piece"/>
        /// </summary>
        /// <param name="type"><see cref="Type"/></param>
        /// <param name="color"><see cref="Color"/></param>
        public Piece(PieceType type, PieceColor color)
        {
            _type = type;
            _color = color;

            Moves = new List<Move>();
            Attacked = new List<Square>();
        }

 public ChessPiece()
 {
     gameObject = null;
     playerSide = PlayerSide.e_NoneSide;
     pieceType = PieceType.e_None;
     piecePlayerType = PiecePlayerType.eNone_Piece;
     bEnPassantCapture = false;
 }

        public bool IsMoveValid(int fromRow, int fromColumn, int toRow, int toColumn, PieceType fromPieceType,
            PieceType toPieceType, PlayerType playerInTurn)
        {
            if (IsJumping(fromRow, fromColumn, toRow, toColumn)) return false;
            if (!IsOriginValid(fromPieceType, playerInTurn)) return false;
            if (!IsMovingForward(fromRow, toRow, playerInTurn)) return false;

            return IsDestinationValid(fromColumn, toColumn, toPieceType, playerInTurn);
        }

 public Piece( PieceType type, PieceColor color )
 {
     if (type == PieceType.None)
         throw new ArgumentException("Type must be specified");
     if (color == PieceColor.None)
         throw new ArgumentException("Color must be specified");
     _type = type;
     _color = color;
 }

 public Move(int from_x, int from_y, int to_x, int to_y, PieceType moved_type, bool promote)
 {
     this.from_rank = from_x;
     this.from_file = from_y;
     this.to_rank = to_x;
     this.to_file = to_y;
     this.promote = promote;
     this.moved_type = moved_type;
 }

    private void SpawnPiece(PlayerType p, PieceType t, Position pos, Transform parent)
    {
        GameObject go = Instantiate(piecePrefab) as GameObject;
        Piece piece = go.GetComponent<Piece>();
        go.transform.parent = parent;

        piece.Set(p, t, pos);
        GameController.Instance.board.GetField(pos).Occupy(piece);
    }

 /// <summary>
 /// Piece constructor
 /// </summary>
 /// <param name="position">The position on the game board</param>
 /// <param name="type">The type piece</param>
 /// <param name="side">The side (team)</param>
 /// <param name="texturePath">A relative path to an image file</param>
 /// <param name="directionVector">A list of vectors defining the movement pattern of the piece</param>
 /// <param name="moveReach">How many steps the piece can move</param>
 public Piece(Point position, PieceType type, Side side, string texturePath, List<Point> directionVector, int moveReach)
 {
     this.position = position;
     this.type = type;
     this.side = side;
     LoadTexture(texturePath);
     this.directionVector = directionVector;
     this.moveReach = moveReach;
 }

        public void LoadPiece(PieceType type, Drawable piece)
        {
            Bitmap bitmap = Bitmap.CreateBitmap (piece_size, piece_size, Bitmap.Config.Argb8888);
            Canvas canvas = new Canvas (bitmap);

            piece.SetBounds (0, 0, piece_size, piece_size);
            piece.Draw (canvas);

            piece_bitmaps[(int)type] = bitmap;
        }

        public Piece(PieceType type, int x, int y)
        {
            if (0 > x || x > 7)
                throw new ArgumentOutOfRangeException("x", "Invalid x position");
            if (0 > y || y > 7)
                throw new ArgumentOutOfRangeException("x", "Invalid y position");

            ChessType = type;
            X = x;
            Y = y;
        }

 public Piece(PieceType type)
 {
     if (type == PieceType.Straight)
         pieces = new List<Texture>()
         {
             DrawManager.CreateTexture("Tetris - Blue Piece", "Blue Piece", Vector2.Zero, DrawManager.ImagePosition.TopLeft),
             DrawManager.CreateTexture("Tetris - Blue Piece", "Blue Piece", DrawManager.GetTexture("Tetris - Blue Piece").Width(), DrawManager.ImagePosition.TopLeft),
             DrawManager.CreateTexture("Tetris - Blue Piece", "Blue Piece", 2 * DrawManager.GetTexture("Tetris - Blue Piece").Width(), DrawManager.ImagePosition.TopLeft),
             DrawManager.CreateTexture("Tetris - Blue Piece", "Blue Piece", 3 * DrawManager.GetTexture("Tetris - Blue Piece").Width(), DrawManager.ImagePosition.TopLeft),
         };
 }