Question

import gpdraw.*;

public class Y2K {

// Attributes
SketchPad pad;
DrawingTool pen;

// Constructor
public Y2K() {

    pad = new SketchPad(600, 600, 50);
    pen = new DrawingTool(pad);

    // Back the pen up so the Y is drawn in the middle of the screen
    pen.up();
    pen.setDirection(270);
    pen.forward(150);
    pen.down();
    pen.setDirection(90);
}

public void drawY(int level, double length) {

    // Base case:  Draw an Y
    if (level == 0) {

        //pen.setDirection(90);
        pen.forward(length);
        pen.turnRight(60);
        pen.forward(length);
        pen.backward(length);
        pen.turnLeft(120);
        pen.forward(length);
        pen.backward(length);
    }


    // Recursive case:  Draw an L at each midpoint
    // of the current L's segments
    else {


            //Drawing the bottom "leg" of our Y shape
            pen.forward(length / 2);
            double xpos1 = pen.getXPos();
            double ypos1 = pen.getYPos();
            double direction1 = pen.getDirection();


            pen.turnRight(90);
            drawY(level - 1, length / 2.0);

            pen.up();
            pen.move(xpos1, ypos1);
            pen.setDirection(direction1);
            pen.down();
            pen.forward(length / 2);

            double xpos2 = pen.getXPos();
            double ypos2 = pen.getYPos();
            double direction2 = pen.getDirection();

            //Drawing upper Right Leg
            pen.turnRight(60);
            pen.forward(length / 2); //going to the midpoint
            double xpos3 = pen.getXPos();
            double ypos3 = pen.getYPos();
            double direction3 = pen.getDirection();
            pen.turnLeft(90);
            drawY(level - 1, length / 2.0);

            pen.up();
            pen.move(xpos3, ypos3);
            pen.setDirection(direction3);
            pen.down();
            pen.forward(length / 2);

            //drawing upper left leg
            pen.up();
            pen.move(xpos1, ypos1);
            pen.setDirection(direction1);
            pen.down();
            pen.forward(length / 2);

            pen.turnLeft(60);
            pen.forward(length / 2);
            double xpos4 = pen.getXPos();
            double ypos4 = pen.getYPos();
            double direction4 = pen.getDirection();

            pen.turnLeft(90);
            drawY(level - 1, length / 2.0);

            pen.up();
            pen.move(xpos4, ypos4);
            pen.setDirection(direction4);
            pen.down();
            pen.forward(length / 2);
            pen.forward(length / 2);
        }

}

public static void main(String[] args) {

    Y2K fractal = new Y2K();

    // Draw Y with given level and side length
    fractal.drawY(8, 200);
}   


}

output:

one certain leg of the triangle is too long, and that makes the output slightly off. maybe its because the code went (length/2) too far? lets debug this.

otherwise it is completely fine, the recursion is great, and its exactly what i wanted to do

Answer 1

As you’re constantly drawing Y’s, I’d recommend you create a method that draws a Y given certain parameters (e.g. length, angle of separation between the two branches of the Y, rotation, etc.). This will make your code much more readable and easier to understand.

As for moving to the center, just think of the Y on a coordinate plane. Based upon the rotation of the Y, and its starting point you can calculate the center point.

Just break it up into its x and y components.

Given this information, we can solve for a and for b.

a = length * sin(θ)
b = length * cos(θ)

Then add this to your x and y to calculate the center point of the Y.

As for keeping the constant length, you know the level. At the first level, level == 1. But the length of this next level should be length * (2^level). In this case, length/2 (as length would be -1).

In pseudo code terms:

public void drawY(int level, double length)
{
    //Drawing the bottom "leg" of our Y shape
    Move Forward length/2
    Save our position 
    Save our direction

    Turn to the right 90 degrees
    Recursion (call drawY())

    revert to original location
    revert to original direction
    move forward length/2 (to go to center point of Y)

    save our new position
    save our new direction 

    //Drawing upper Right Leg
    Turn 60 to the right
    Move Forward length/2 //going to the midpoint
    save our new position (don't forget the center point)
    save our new direction (don't forget the center point direction)
    Turn 90 to the left
    Recursion (call drawY())

    return to our saved position (not center one)
    return to our saved direction (not center one)

    move forward length/2

    //drawing upper left leg
    return to center point
    return to center direction

    turn left 60 
    move forward length/2
    save position (you can overwrite the center one now
    save direction (you can overwrite)

    turn left 90
    Recursion (call drawY())

    return to position
    return to direction
    move forward length/2
}