Esempio n. 1
0
 private static void PartOfSquare(double angle1, double angle2, double angle3, double angle4)
 {
     Risovatel.Go(100, angle1);
     Risovatel.Go(10 * Math.Sqrt(2), angle2);
     Risovatel.Go(100, angle3);
     Risovatel.Go(100 - (double)10, angle4);
 }
Esempio n. 2
0
        public static void Main()
        {
            Risovatel.Initialize();

            //Рисуем четыре одинаковые части невозможного квадрата.
            // Часть первая:
            Risovatel.set_pos(10, 0);
            Risovatel.Go(100, 0);
            Risovatel.Go(10 * Math.Sqrt(2), Math.PI / 4);
            Risovatel.Go(100, Math.PI);
            Risovatel.Go(100 - (double)10, Math.PI / 2);

            // Часть вторая:
            Risovatel.set_pos(120, 10);
            Risovatel.Go(100, Math.PI / 2);
            Risovatel.Go(10 * Math.Sqrt(2), Math.PI / 2 + Math.PI / 4);
            Risovatel.Go(100, Math.PI / 2 + Math.PI);
            Risovatel.Go(100 - (double)10, Math.PI / 2 + Math.PI / 2);

            // Часть третья:
            Risovatel.set_pos(110, 120);
            Risovatel.Go(100, Math.PI);
            Risovatel.Go(10 * Math.Sqrt(2), Math.PI + Math.PI / 4);
            Risovatel.Go(100, Math.PI + Math.PI);
            Risovatel.Go(100 - (double)10, Math.PI + Math.PI / 2);

            // Часть четвертая:
            Risovatel.set_pos(0, 110);
            Risovatel.Go(100, -Math.PI / 2);
            Risovatel.Go(10 * Math.Sqrt(2), -Math.PI / 2 + Math.PI / 4);
            Risovatel.Go(100, -Math.PI / 2 + Math.PI);
            Risovatel.Go(100 - (double)10, -Math.PI / 2 + Math.PI / 2);

            Risovatel.ShowResult();
        }
Esempio n. 3
0
 public static void DrawSquare(int x, int y, int index)
 {
     Risovatel.set_pos(x, y);
     Risovatel.Go(100, Math.PI * index / 2);
     Risovatel.Go(10 * Math.Sqrt(2), Math.PI / 4 + (Math.PI * index / 2));
     Risovatel.Go(100, ((Math.PI * index) / 2) + Math.PI);
     Risovatel.Go(100 - (double)10, Math.PI / 2 + (Math.PI * index / 2) % (2 * Math.PI));
 }
Esempio n. 4
0
 /// <summary>
 /// рисует одну часть невозможного квадрата
 /// </summary>
 /// <param name="x0">начальная координата x</param>
 /// <param name="y0">начальная координата Y</param>
 /// <param name="angle">угол направления части</param>
 static void DrowPart(double x0, double y0, double angle)
 {
     Risovatel.SetPos((float)x0, (float)y0);
     Risovatel.Go(Length, angle);
     Risovatel.Go(Width * Math.Sqrt(2), angle + Math.PI / 4);
     Risovatel.Go(Length, angle + Math.PI);
     Risovatel.Go(Length - Width, angle + 2 * Math.PI / Num);
 }
Esempio n. 5
0
 public static void DrawPart(int i)
 {
     Risovatel.SetPos(Pos[(i + 1) % 4], Pos[i % 4]);
     Risovatel.Go(100, Math.PI / 2 * i);
     Risovatel.Go(10 * Math.Sqrt(2), Math.PI / 4 + Math.PI / 2 * i);
     Risovatel.Go(100, Math.PI + Math.PI / 2 * i);
     Risovatel.Go(100 - (double)10, Math.PI / 2 + Math.PI / 2 * i);
 }
 private static void MyNewMethod(int x, int y, int k) // волшебный метод, рисует сторону по значениям
 {
     Risovatel.SetPos(x, y);
     Risovatel.Go(100, k * Math.PI / 2);
     Risovatel.Go(10 * Math.Sqrt(2), k * Math.PI / 2 + Math.PI / 4);
     Risovatel.Go(100, k * Math.PI / 2 + Math.PI);
     Risovatel.Go(100 - (double)10, k * Math.PI / 2 + Math.PI / 2);
 }
        public static void DrawPart(int i)
        {
            double angle = Math.PI / 2 * i;

            Risovatel.SetPos(Pos[(i + 1) % 4], Pos[i % 4]);
            Risovatel.Go(10 * size, angle);
            Risovatel.Go(1 * size * Math.Sqrt(2), Math.PI / 4 + angle);
            Risovatel.Go(10 * size, Math.PI + angle);
            Risovatel.Go(10 * size - (double)1 * size, Math.PI / 2 + angle);
        }
        public static void Main()
        {
            Risovatel.Initialize();

            for (int i = 0; i < 4; i++)
            {
                DrawPart(i);
            }

            Risovatel.ShowResult();
        }
Esempio n. 9
0
        public static void Main()
        {
            Risovatel.Initialize();

            Risovatel.DrawSquare(10, 0, 0);
            Risovatel.DrawSquare(120, 10, 1);
            Risovatel.DrawSquare(110, 120, 2);
            Risovatel.DrawSquare(0, 110, 3);

            Risovatel.ShowResult();
        }
Esempio n. 10
0
        public static void Main()
        {
            Risovatel.Initialize();

            //рисует первую часть
            StrangeThing.DrowPart(Width, 0, 0);
            //рисует вторую часть
            StrangeThing.DrowPart(Length + 2 * Width, Width, 2 * Math.PI / Num);
            //рисует третью часть
            StrangeThing.DrowPart(Length + Width, Length + 2 * Width, 4 * Math.PI / Num);
            //рисует четвёртую часть
            StrangeThing.DrowPart(0, Length + Width, 6 * Math.PI / Num);

            Risovatel.ShowResult();
        }
        public static void Main()
        {
            //Рисуем четыре одинаковые части невозможного квадрата.
            // Часть первая:
            Risovatel.Draw_Parts(xLUpperPos + width, yLUpperPos, 0);
            // Часть вторая:
            Risovatel.Draw_Parts(xLUpperPos + (2 * width) + sideLength, yLUpperPos + width, Math.PI / 2);

            // Часть третья:
            Risovatel.Draw_Parts(xLUpperPos + width + sideLength, yLUpperPos + (2 * width) + sideLength, Math.PI);

            // Часть четвертая:
            Risovatel.Draw_Parts(xLUpperPos, yLUpperPos + width + sideLength, (-1) * Math.PI / 2);
            Risovatel.ShowResult();
        }
Esempio n. 12
0
        public static void Draw_Part_Squere(float x, float y, int k)
        {
            double pi1 = 0;

            for (int i = 1; i < k; ++i)
            {
                pi1 += Math.PI / 2;
            }
            //Console.WriteLine(pi1);
            Risovatel.Set_pos(x, y);
            Risovatel.Draw_line(100, pi1);
            Risovatel.Draw_line(10 * Math.Sqrt(2), pi1 + Math.PI / 4);
            Risovatel.Draw_line(100, pi1 + Math.PI);
            Risovatel.Draw_line(100 - (double)10, pi1 + Math.PI / 2);
            //pi1 += Math.PI / 2;
        }
        public static void Main()
        {
            //Рисуем четыре одинаковые части невозможного квадрата.
            // Часть первая:

            MyNewMethod(10, 0, 0);

            // Часть вторая:
            MyNewMethod(120, 10, 1);

            // Часть третья:
            MyNewMethod(110, 120, 2);
            // Часть четвертая:
            MyNewMethod(0, 110, 3);
            Risovatel.ShowResult();
        }
Esempio n. 14
0
        public static void Main()
        {
            Risovatel.Initialize();

            int[] Pos;
            Pos[0] = 0;
            Pos[1] = 10;
            Pos[2] = 120;
            Pos[3] = 110;

            for (int i = 0; i < 4; i++)
            {
                DrawPart(i);
            }

            Risovatel.ShowResult();
        }
Esempio n. 15
0
        public static void Main()
        {
            Risovatel.Initialize();

            //Рисуем четыре одинаковые части невозможного квадрата.
            // Часть первая:
            Risovatel.SetPos(Risovatel.width, 0);

            // Часть вторая:
            Risovatel.SetPos(Risovatel.a + 2 * Risovatel.width, Risovatel.width);

            // Часть третья:
            Risovatel.SetPos(Risovatel.a + Risovatel.width, Risovatel.a + Risovatel.width * 2);

            // Часть четвертая:
            Risovatel.SetPos(0, Risovatel.a + Risovatel.width);

            Risovatel.ShowResult();
        }
Esempio n. 16
0
        public static void Main()
        {
            Risovatel.Create_file();

            /*
             * //Рисуем четыре одинаковые части невозможного квадрата.
             * // Часть первая:
             * Risovatel.Set_pos(10, 0);
             * Risovatel.Draw_line(100, 0);
             * Risovatel.Draw_line(10 * Math.Sqrt(2), Math.PI / 4);
             * Risovatel.Draw_line(100, Math.PI);
             * Risovatel.Draw_line(100 - (double)10, Math.PI / 2);
             *
             * // Часть вторая:
             * Risovatel.Set_pos(120, 10);
             * Risovatel.Draw_line(100, Math.PI / 2);
             * Risovatel.Draw_line(10 * Math.Sqrt(2), Math.PI / 2 + Math.PI / 4);
             * Risovatel.Draw_line(100, Math.PI / 2 + Math.PI);
             * Risovatel.Draw_line(100 - (double)10, Math.PI / 2 + Math.PI / 2);
             *
             * // Часть третья:
             * Risovatel.Set_pos(110, 120);
             * Risovatel.Draw_line(100, Math.PI);
             * Risovatel.Draw_line(10 * Math.Sqrt(2), Math.PI + Math.PI / 4);
             * Risovatel.Draw_line(100, Math.PI + Math.PI);
             * Risovatel.Draw_line(100 - (double)10, Math.PI + Math.PI / 2);
             *
             * // Часть четвертая:
             * Risovatel.Set_pos(0, 110);
             * Risovatel.Draw_line(100, -Math.PI / 2);
             * Risovatel.Draw_line(10 * Math.Sqrt(2), -Math.PI / 2 + Math.PI / 4);
             * Risovatel.Draw_line(100, -Math.PI / 2 + Math.PI);
             * Risovatel.Draw_line(100 - (double)10, -Math.PI / 2 + Math.PI / 2);
             */
            Draw_Part_Squere(10, 0, 1);
            Draw_Part_Squere(120, 10, 2);
            Draw_Part_Squere(110, 120, 3);
            Draw_Part_Squere(0, 110, 4);

            Risovatel.ShowResult();
            //Console.ReadLine();
        }
Esempio n. 17
0
        public static void Main()
        {
            Risovatel.Initialize();

            //Рисуем четыре одинаковые части невозможного квадрата.
            // Часть первая:
            Risovatel.Set_pos(10, 0);// 0, Math.PI / 4, Math.PI, Math.PI / 2
            PartOfSquare(0, Math.PI / 4, Math.PI, Math.PI / 2);

            // Часть вторая:
            Risovatel.Set_pos(120, 10);
            PartOfSquare(Math.PI / 2, 3 * Math.PI / 4, 3 * Math.PI / 2, Math.PI);

            // Часть третья:
            Risovatel.Set_pos(110, 120);
            PartOfSquare(Math.PI, Math.PI + Math.PI / 4, 2 * Math.PI, Math.PI + Math.PI / 2);

            // Часть четвертая:
            Risovatel.Set_pos(0, 110);
            PartOfSquare(-Math.PI / 2, -Math.PI / 2 + Math.PI / 4, -Math.PI / 2 + Math.PI, -Math.PI / 2 + Math.PI / 2);

            Risovatel.ShowResult();
        }