//-----------------------------------------------------------------------------------------------
	
	public void Add(Figure figure)
	{
		for (int y = 0; y < figure.form.GetLength(0); y++)
			for (int x = 0; x < figure.form.GetLength(1); x++)
				if (figure.form[y, x] && y+figure.position.Y>=0)
					this.cells[y + figure.position.Y, x + figure.position.X] = true;
	}

        public virtual void ExecuteFigureCreationCommand(string[] splitFigString)
        {
            switch (splitFigString[0])
            {
                case "vertex":
                    {
                        Vector3D location = Vector3D.Parse(splitFigString[1]);
                        currentFigure = new Vertex(location);
                        break;
                    }
                case "segment":
                    {
                        Vector3D a = Vector3D.Parse(splitFigString[1]);
                        Vector3D b = Vector3D.Parse(splitFigString[2]);
                        currentFigure = new LineSegment(a, b);
                        break;
                    }
                case "triangle":
                    {
                        Vector3D a = Vector3D.Parse(splitFigString[1]);
                        Vector3D b = Vector3D.Parse(splitFigString[2]);
                        Vector3D c = Vector3D.Parse(splitFigString[3]);
                        currentFigure = new Triangle(a, b, c);
                        break;
                    }
            }

            this.EndCommandExecuted = false;
        }

 static void Main()
 {
     Figure fig = new Figure(3, 2);
     fig = fig.Rotate(fig, 30);
     Console.WriteLine(fig.Width);
     Console.WriteLine(fig.Height);
 }

 public SquareItem(Square square, Figure figure, Color color)
 {
     this.innerSquare = square;
     this.SetBackgroundColor(square);
     this.FigureType = figure;
     this.FigureColor = color;
     this.ColoredFigure = ColoredFigureHelper.Create(color, figure);
 }

 public void Hit(Figure newFig)
 {
     this.figure.x = newFig.x;
     this.figure.y = newFig.y;
     Console.WriteLine("Figure is hit");
     newFig.changeAbToMove();
     Console.WriteLine("New current koords are x:" + this.figure.x + ", y:" + this.figure.y);
 }

 /// <summary>
 /// Resets the original setup
 /// </summary>
 public static void Reset()
 {
     hasToGoBackwards = false;
     turnIsRunning = false;
     currentFigure = null;
     currentStep = 0;
     lastStep = 0;
 }

 public Figure Rotate(Figure figure, double angleForRotate)
 {
     double newWidth = Math.Abs(Math.Cos(angleForRotate)) * figure.Width +
         Math.Abs(Math.Sin(angleForRotate)) * figure.Height;
     double newHeight = Math.Abs(Math.Sin(angleForRotate)) * figure.Width +
         Math.Abs(Math.Cos(angleForRotate)) * figure.Height;
     figure = new Figure(newWidth, newHeight);
     return figure;
 }

        public static Figure GetRotatedSize(Figure figure, double angleToRotateInDegree)
        {
            double angle = angleToRotateInDegree;

            double rotatedWidth = Math.Abs(Math.Cos(angle)) * figure.Width + Math.Abs(Math.Sin(angle)) * figure.Height;
            double rotatedHeight = Math.Abs(Math.Sin(angle)) * figure.Width + Math.Abs(Math.Cos(angle)) * figure.Height;

            return new Figure(rotatedWidth, rotatedHeight);
        }

 static void Main()
 {
     Figure figure = new Figure(1, 2);
     figure.Width = -6;
     Console.WriteLine(figure.Width);
     figure = Figure.GetRotatedFigure(figure, 5);
     Console.WriteLine(figure.Width);
     Console.WriteLine(figure.Height);
 }

        public static void Main(string[] args)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            Figure original = new Figure(2, 5);
            PrintFigureWidthAndHeight(original);

            Figure rotated = Figure.GetRotatedFigure(original, 90);
            PrintFigureWidthAndHeight(rotated);
        }

 /// <summary>
 /// Return a gamefigure if there is one to send home. otherwise null is returned
 /// </summary>
 /// <param name="figure"></param>
 /// <returns></returns>
 public Figure GetFigureToSendHome(Figure figure)
 {
     if (isBench) return null;
     ArrayList figuresOnField = GetFiguresOnField();
     if (figuresOnField.Count == 0) return null;
     Figure figureToSendHome = (Figure)figuresOnField[0];
     if (FigureCtrl.GetPlayer(figureToSendHome).Color.Equals(FigureCtrl.GetPlayer(figure).Color))
         return null;
     return figureToSendHome;
 }

    public static Figure RotateFigure(Figure currentFigure, double rotationAngleInRadians)
    {
        double rotatedWidth = Math.Abs(Math.Cos(rotationAngleInRadians)) * currentFigure.Width +
            Math.Abs(Math.Sin(rotationAngleInRadians)) * currentFigure.Height;
        double rotatedHeight = Math.Abs(Math.Sin(rotationAngleInRadians)) * currentFigure.Width +
            Math.Abs(Math.Cos(rotationAngleInRadians)) * currentFigure.Height;
        Figure rotatedFigure = new Figure(rotatedWidth, rotatedHeight);

        return rotatedFigure;
    }

    public static Figure GetRotatedFigure(Figure figure, double angleOfRotation)
    {
        double rotatedSizeWidth = (Math.Abs(Math.Cos(angleOfRotation)) * figure.Width) +
            (Math.Abs(Math.Sin(angleOfRotation)) * figure.Heigth);
        double rotatedSizeHeight = (Math.Abs(Math.Sin(angleOfRotation)) * figure.Width) +
            (Math.Abs(Math.Cos(angleOfRotation)) * figure.Heigth);

        Figure rotatedFigure = new Figure(rotatedSizeWidth, rotatedSizeHeight);

        return rotatedFigure;
    }

 /// <summary>
 /// fetches a text randomly and displays it
 /// </summary>
 /// <param name="figure"></param>
 public static void ShowRandomText(Figure figure)
 {
     if (isActive)
     {
         if (notYetDisplayedTexts.Count == 0)
             notYetDisplayedTexts.AddRange(texts);
         int randomIndex = UnityEngine.Random.Range(0, notYetDisplayedTexts.Count);
         string text = (string)notYetDisplayedTexts[randomIndex];
         ShowText(figure, text);
         notYetDisplayedTexts.Remove(text);
     }
 }

 public object Clone()
 {
     var copied = new Figure(this.Body);
     copied.Elements = GetFigureFromArray(copied.Body);
     copied.Position = this.Position;
     for (int i = 0; i < copied.Elements.Count; i++)
     {
         copied.Elements[i].Position.Left = this.Elements[i].Position.Left;
         copied.Elements[i].Position.Top = this.Elements[i].Position.Top;
     }
     return copied;
 }

 private void drawQuetion(Graphics g)
 {
     List<Figure> figures = generateQuetion();
     int i = 0, x = 0, y = 0;
     while (i < 8) {
         drawFigure(g, x, y, figures[i]);
         x += offset;
         if (i == 2 || i == 5) { y += offset; x = 0; }
         i += 1;
     }
     answer = figures[8];
 }

    //Methods:
    public static Figure GetRotatedFigure(Figure size, double angle)
    {
        double cosWidth = Math.Abs(Math.Cos(angle)) * size.Width;
        double sinHeight = Math.Abs(Math.Sin(angle)) * size.Height;
        double sinWidth = Math.Abs(Math.Sin(angle)) * size.Width;
        double cosHeight = Math.Abs(Math.Cos(angle)) * size.Height;

        double newWidth = cosWidth + sinHeight;
        double newHeight = sinWidth + cosHeight;

        return new Figure(newWidth, newHeight);
    }

    public void ConnectTo(Figure figure)
    {
        foreach (Pin pin in pins) {
            pin.position = pin.position + position - figure.position;
            pin.transform.parent = figure.transform.FindChild("PinWrapper");
        }

        int arrayOriginalSize = figure.pins.Length;
        Array.Resize< Pin >(ref figure.pins, figure.pins.Length + pins.Length);
        Array.Copy(pins, 0, figure.pins, arrayOriginalSize, pins.Length);
        pins = new Pin[0];
        Reinit();
    }

        public List<Position> GetMoves(Figure figure, ChessField cf)
        {
            Position pos = figure.Position;
            List<Position> l = new List<Position>();
            switch (figure.GetFigureType())
            {
                case FigureTypes.King:
                    {

                        break;
                    }
            }
        }

    public static Figure GetRotatedFigure(Figure figure, double rotatedFigureAngle)
    {
        double width;
        double height;

        width = Math.Abs(Math.Cos(rotatedFigureAngle)) * figure.width +
            Math.Abs(Math.Sin(rotatedFigureAngle)) * figure.height;
        height = Math.Abs(Math.Sin(rotatedFigureAngle)) * figure.width +
            Math.Abs(Math.Cos(rotatedFigureAngle)) * figure.height;

        Figure rotatedFigure = new Figure(width, height);

        return rotatedFigure;
    }