API tools faq
paste
Advertisement
TheHund

ToCS

TheHund
Oct 23rd, 2019
118
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 11.82 KB | None | 0 0
raw download clone embed print report
  1.  package Turtle;
  2.  
  3.  
  4. import turtlePck.TurtleGraphicsWindow;
  5. import java.lang.Math;
  6.  
  7.  
  8. /*
  9.  * To change this template, choose Tools | Templates
  10.  * and open the template in the editor.
  11.  */
  12.  
  13. /**
  14.  *
  15.  * @author ZTILabPI
  16.  */
  17. public class TurtleAlgorithms extends TurtleGraphicsWindow{
  18.    
  19.     public void positioningTurtle(int angle){
  20.         right(angle);
  21.     }
  22.  
  23.      
  24.     public void sierpinski(int bok, int minBok ){
  25.          if (bok<minBok) {
  26.             return;
  27.         }
  28.           for(int i=1;i<4;i++){
  29.               sierpinski(bok/2, minBok);
  30.               forward(bok);
  31.               right(120);
  32.           }
  33.       }
  34.     public void A1(int bok, int minBok ){
  35.          if (bok<minBok) {
  36.             return;
  37.         }
  38.           for(int i=1;i<5;i++){
  39.               forward(bok);
  40.               A1(bok/2, minBok);
  41.               right(90);
  42.  
  43.           }
  44.       }
  45.     public void A2(int bok, int minBok ){
  46.          if (bok<minBok) {
  47.             return;
  48.         }
  49.           for(int i=1;i<4;i++){
  50.               forward(bok);
  51.               A2(bok/2, minBok);
  52.               right(120);
  53.           }
  54.       }
  55.     public void A3(int bok, int minBok ){
  56.          if (bok<minBok) {
  57.             return;
  58.         }
  59.           for(int i=1;i<5;i++){
  60.               forward(bok);
  61.               right(270);
  62.               A3(bok/2, minBok);
  63.               right(180);
  64.  
  65.           }
  66.       }
  67.     public void A4(int bok, int minBok ){
  68.          if (bok<minBok) {
  69.             return;
  70.         }
  71.           for(int i=1;i<4;i++){
  72.               forward(bok);
  73.               right(300);
  74.               A4(bok/2, minBok);
  75.               right(180);
  76.  
  77.           }
  78.       }
  79.     public void A5(int bok, int minBok ){
  80.          if (bok<minBok) {
  81.             return;
  82.         }
  83.           for(int i=1;i<4;i++){
  84.               forward(bok);
  85.               left(300);
  86.               A5(bok/2, minBok);
  87.               left(300);
  88.  
  89.           }
  90.       }
  91.     public void A6(int bok, int minBok ){
  92.          if (bok<minBok) {
  93.             return;
  94.         }
  95.           for(int i=1;i<5;i++){
  96.               forward(bok/4);
  97.               right(90);
  98.               A6(bok/2, minBok);
  99.               left(90);
  100.               forward(3*bok/4);
  101.               left(90);
  102.           }
  103.       }
  104.     public void A7(int bok, int minBok ){
  105.          if (bok<minBok) {
  106.             return;
  107.         }
  108.           for(int i=1;i<4;i++){
  109.               forward(bok/4);
  110.               right(60);
  111.               A7(bok/2, minBok);
  112.               left(60);
  113.               forward(3*bok/4);
  114.               left(120);
  115.           }
  116.       }
  117.     public void A8(int bok, int minBok ){
  118.          if (bok<minBok) {
  119.             return;
  120.         }
  121.           for(int i=1;i<7;i++){
  122.               forward(bok/4);
  123.               left(120);
  124.               A8(bok/2, minBok);
  125.               right(120);
  126.               forward(3*bok/4);
  127.               left(300);
  128.           }
  129.       }
  130.     public void A9(int bok, int minBok ){
  131.          if (bok<minBok) {
  132.             forward(bok);
  133.             right(90);
  134.             forward(bok/2);
  135.             return;
  136.         }
  137.           for(int i=1;i<2;i++){
  138.               forward(bok);
  139.               right(90);
  140.               A9(bok-8, minBok);
  141.           }
  142.       }
  143.     public void A10(int bok, int minBok ){
  144.          if (bok<minBok) {
  145.             forward(bok);
  146.             left(120);
  147.             forward(bok/2);
  148.             return;
  149.         }
  150.           for(int i=1;i<2;i++){
  151.               forward(bok);
  152.               left(120);
  153.               A10(bok-8, minBok);
  154.           }
  155.       }
  156.     public void A11(int bok, int minBok ){
  157.          if (bok<minBok) {
  158.              left(60);
  159.              forward(bok);
  160.              left(60);
  161.              forward(bok/2);
  162.              left(60);
  163.              forward(bok/2);
  164.             return;
  165.         }
  166.           for(int i=1;i<2;i++){
  167.               left(60);
  168.               forward(bok);
  169.  
  170.               A11(bok-10, minBok);
  171.           }
  172.       }
  173.     public void A12(int bok, int minBok ){
  174.          if (bok<minBok) {
  175.             return;
  176.         }
  177.           for(int i=1;i<4;i++){
  178.               forward(bok/2);
  179.               A12(bok/3, minBok);
  180.               forward(bok);
  181.               right(120);
  182.               A12(bok/3, minBok);
  183.              
  184.              
  185.           }
  186.       }
  187.     public void A13(int bok, int minBok ){
  188.          if (bok<minBok) {
  189.             return;
  190.         }
  191. //          for(int i=1;i<2;i++){
  192.             forward(bok);
  193.             left(45);
  194.             A13(6*bok/9, minBok);
  195.             right(90);
  196.             A13(6*bok/9, minBok);
  197.             left(45);
  198.             back(bok);
  199.              
  200. //          }
  201.       }
  202.     public void B1(int bok, int minBok ){
  203.          if (bok<minBok) {
  204.             return;
  205.         }
  206.           for(int i=0;i<4;i++){
  207.  
  208.              forward(bok);
  209.              left(90);
  210.              forward(bok);
  211.              left(90);
  212.  
  213.  
  214.  
  215.              B1(bok/2,minBok);
  216.              
  217.           }
  218.       }
  219.     public void B2(int bok, int minBok ){
  220.          if (bok<minBok) {
  221.             return;
  222.         }
  223.           for(int i=1;i<7;i++){
  224.               forward(bok);
  225.               right(60);
  226.               forward(bok/2);
  227.               left(120);
  228.               forward(bok/8);
  229.               left(120);
  230.               B2(bok/2, minBok);
  231.               right(120);
  232.               forward((3*bok)/4);
  233.               right(60);
  234.              
  235.          }
  236.       }
  237.     public void B3(int bok, int minBok ){
  238.          if (bok<minBok) {
  239.             return;
  240.         }
  241.           for(int i=1;i<5;i++){
  242.               forward(bok);
  243.               right(90);
  244.               forward(bok/4);
  245.               left(90);
  246.               B3(bok/2, minBok);
  247.               right(90);
  248.               forward((3*bok)/4);
  249.               left(270);
  250.              
  251.          }
  252.       }
  253.     public void B4(int bok, int minBok ){
  254.          if (bok<minBok) {
  255.             return;
  256.         }
  257.           for(int i=0;i<4;i++)
  258.           {
  259.              
  260.               forward(bok);
  261.               if(i%2==0)
  262.               {
  263.                right(90);
  264.                B4(bok/2, minBok);
  265.                left(90);
  266.               }
  267.                left(90);
  268.              
  269.              
  270.                  
  271.              
  272.           }
  273.       }
  274.     public void B5(int bok, int minBok ){
  275.          if (bok<minBok) {
  276.             return;
  277.         }
  278.           for(int i=1;i<5;i++){
  279.               B5(bok/3, minBok);
  280.               forward(bok/2);
  281.               right(90);
  282.              
  283.          }
  284.       }
  285.     public void B6(int bok, int minBok ){
  286.          if (bok<minBok) {
  287.             return;
  288.         }
  289.           for(int i=1;i<4;i++){
  290.             forward(bok);
  291.             left(120);
  292.             B6(bok/3, minBok);
  293.              
  294.          }
  295.       }
  296.     public void B7(int bok, int minBok ){
  297.          if (bok<minBok) {
  298.             return;
  299.         }
  300.           for(int i=1;i<7;i++){
  301.               B7(bok/2, minBok);
  302.               forward(bok);
  303.               right(300);
  304.               forward(bok/4);
  305.               left(300);
  306.               right(300);
  307.               forward((3*bok)/4);
  308.               left(60);
  309.              
  310.          }
  311.       }  
  312.     public void B8(int bok, int minBok) {
  313.         left(45);
  314.         for (int i = 0; i < 3; i++) {
  315.             forward(bok);
  316.             if (bok > minBok) {
  317.                 B8(bok / 2, minBok);
  318.             }
  319.             back(bok);
  320.             right(45);
  321.         }
  322.         left(90);
  323.     }
  324.     public void C1(int bok, int minBok ){
  325.          if (bok<minBok) {
  326.             return;
  327.         }
  328.           for(int i=0;i<1;i++)
  329.           {
  330.              
  331.  
  332.           forward(bok);
  333.           left(125);
  334.           C1(bok-4,minBok);
  335.          
  336.          
  337.           }
  338.       }
  339.     public void C2(int bok, int minBok ){
  340.          if (bok<minBok) {
  341.             return;
  342.         }
  343.           for(int i=1;i<2;i++){
  344.              forward(bok);
  345.              left(144);
  346.              C2(bok-8, minBok);
  347.              
  348.          }
  349.       }  
  350.     public void C3(int bok, int minBok ){
  351.          if (bok<minBok) {
  352.             return;
  353.         }
  354.           for(int i=0;i<1;i++)
  355.           {
  356.              
  357.  
  358.           forward(bok);
  359.           left(100);
  360.           C3(bok-5,minBok);
  361.  
  362.              
  363.              
  364.                  
  365.              
  366.           }
  367.       }
  368.     public void C4(int bok, int depth ){
  369.         if (depth < 0) {
  370.            return;
  371.         }
  372.         forward(bok);
  373.         left(45);
  374.         C4((int) Math.round(Math.sqrt(2)* (double) bok / 2.0), depth-1);
  375.         right(90);
  376.         forward((int) Math.round(Math.sqrt(2)* (double) bok / 2.0));
  377.         C4((int) Math.round(Math.sqrt(2)* (double) bok / 2.0), depth-1);
  378.         right(90);
  379.         forward((int) Math.round(Math.sqrt(2)* (double) bok / 2.0));
  380.         right(45);
  381.         forward(bok);
  382.         right(90);
  383.         forward(bok);
  384.         right(90);
  385.     }    
  386.  
  387.     public void C5(int bok, int minBok ){
  388.          if (bok<minBok) {
  389.             return;
  390.         }
  391.           for(int i=0;i<4;i++){
  392.  
  393.             C5(bok/3, minBok);  
  394.             forward(bok/3);
  395.  
  396.             C5(bok/3, minBok);
  397.             forward(bok/3);
  398.  
  399.             forward(bok/3);
  400.             left(90);
  401.              
  402.           }
  403.       }
  404.     public void C6(int bok, int depth ){
  405.         if (depth < 0) {
  406.            return;
  407.         }
  408.         C6(bok/2, depth-1);
  409.         for(int j=0;j<3;j++){
  410.             forward(bok);
  411.             C6(bok/2, depth-1);
  412.             back(bok);
  413.             right(120);
  414.         }
  415.     }
  416.  
  417.     public void C7(int bok, int depth ){
  418.         if (depth < 0) {
  419.            return;
  420.         }
  421.         C7(bok/3, depth-1);
  422.         for(int j=0;j<4;j++){
  423.             forward(2*bok/3);
  424.             C7(bok/3, depth-1);
  425.             back(2*bok/3);
  426.             right(90);
  427.         }
  428.     }
  429.      
  430.    
  431. public void snowFlake(int n, int bok){
  432.     if (n==0){
  433.         forward(bok);
  434.         return;
  435.     }
  436.     snowFlake(n-1, bok/3);
  437.     right(60);
  438.     snowFlake(n-1, bok/3);
  439.     left(120);
  440.     snowFlake(n-1, bok/3);
  441.     right(60);
  442.     snowFlake(n-1, bok/3);
  443.  
  444. }
  445.  
  446.  
  447. public void callSnowFlake(int n, int bok){
  448.     for(int i=1; i<4; i++){
  449.       snowFlake(n, bok);
  450.       left(120);
  451.     }
  452. }
  453.  
  454. }
  455.  
  456.  
  457. ///////////////////////////////////////////////////////////////////////////////////////////////////////////
  458.  
  459.  
  460.  
  461. package Turtle;
  462.  
  463. public class Main {
  464.  
  465.     /**
  466.      * @param args the command line arguments
  467.      */
  468.     public static void main(String[] args) {
  469.         // TODO code application logic here
  470.         TurtleAlgorithms alg = new TurtleAlgorithms();
  471. //        alg.positioningTurtle(45);
  472. //        alg. sierpinski(bok, minBok);
  473. //        alg.sierpinski(300, 50);
  474. //        alg.A1(240, 20);
  475. //        alg.A2(240, 20); //position 30
  476. //        alg.A3(210, 10);
  477. //        alg.A4(210, 10); //position 270
  478. //        alg.A5(400, 30); //position 270
  479. //        alg.A6(200, 25); //position 90
  480. //        alg.A7(400, 50); //position 90
  481. //        alg.A8(129, 32); //position 90
  482. //        alg.A9(420, 40); //position 270
  483. //        alg.A10(340, 40); //position 90
  484. //        alg.A11(300, 40); //position 90
  485. //        alg.A12(486, 18); //position 30
  486. //        alg.A13(200, 2);
  487. //        alg.B1(400, 10);
  488. //        alg.B2(100, 25); //position 90
  489. //        alg.B3(200, 20); //position 90
  490. //        alg.B4(200, 10);
  491. //        alg.B5(400, 10);  //position 90
  492. //        alg.B6(600, 20); //position 90
  493. //        alg.B7(200, 25); //position 270
  494. //        alg.B8(300, 30);
  495. //        alg.C1(400, 10); //position 350
  496. //        alg.C2(300, 25); //position 300
  497. //        alg.C3(400, 10); //position 235
  498. //        alg.C4(150, 10);
  499. //        alg.C5(486, 6);
  500. //        alg.C6(200, 4); //position 45
  501. //        alg.C7(450, 5);
  502. //        alg.callSnowFlake(3, 400);
  503. //        alg.snowFlake(3, 400);
  504.     }
  505.    
  506. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!