0

For my project we are supposed to assign moving rectangles a random value between 1 and 3. After each click it should decrease the amount of required clicks to freeze. When the count reaches 0 it freezes. If the frozen rectangle is touched by another it should start moving again with a new random number for the amount of clicks it needs to freeze. I'm stuck on how to get it to freeze with multiple clicks. 

import java.util.Random;
public class Main {

public static void main(String[] args) {

    MovingRectangle[] rectangles = new MovingRectangle[5];


    Random rng = new Random();
    for (int i = 0; i < rectangles.length; i++) {
        rectangles[i] = new MovingRectangle(
                rng.nextDouble(), // x in [0, 1)
                rng.nextDouble(), // y in [0, 1)
                rng.nextDouble() * 0.02 - 0.01, // vx in [-0.01, 0.01)
                rng.nextDouble() * 0.02 - 0.01, // vy in [-0.01, 0.01)
                rng.nextDouble() * 0.2 + 0.1, // width in [0.1, 0.3)
                rng.nextDouble() * 0.2 + 0.1 // height in [0.1, 0.3)
                );
    }

    while (true) {
        StdDraw.clear(StdDraw.GRAY);

        boolean clickCount = false;
        int clickStatus = rng.nextInt(3);
        int frozenCount = 0;
        for (int i = 0; i < rectangles.length; i++) {


                if (StdDraw.mousePressed()) {
                    ++clickStatus;
                    if (clickStatus > 3) {
                        clickStatus = 3;
                    }
                } else {
                    clickStatus = 0;
                }
                if(clickStatus == 3) {
                clickCount = true;
                }   


            if (StdDraw.mousePressed() 
                    && rectangles[i].containsPoint(StdDraw.mouseX(), StdDraw.mouseY()) && (clickCount = true)) {
                rectangles[i].freeze();
            }

            rectangles[i].draw();
            rectangles[i].update();

            if (rectangles[i].isFrozen()) {
                frozenCount++;
            }
            for (int j = i+1; j < rectangles.length; j++) {

                  if (rectangles[i].collidesWith(rectangles[j])) {

                    rectangles[i].unfreeze();
                    rectangles[j].unfreeze();
                  }
                }
        }
        StdDraw.setPenColor(StdDraw.WHITE);
        StdDraw.filledRectangle(0.2, 0.03, 0.2, 0.03);
        StdDraw.setPenColor(StdDraw.BLACK);
        StdDraw.textLeft(0.0, 0.03, "Rectangles remaining: " +
                (rectangles.length - frozenCount));


        if (frozenCount == rectangles.length) {
            StdDraw.setPenColor(StdDraw.WHITE);
            StdDraw.filledRectangle(0.5, 0.5, 0.1, 0.05);
            StdDraw.setPenColor(StdDraw.BLACK);
            StdDraw.text(0.5, 0.5, "You Win!");
        }
        StdDraw.show(25);
    }
}

}

import java.util.Random;

public class MovingRectangle {

private double x;
private double y;


private double vx;
private double vy;
private boolean isFrozen;
private boolean frozen;

private int red;
private int green;
private int blue;


private double halfWidth;
private double halfHeight;


Random rng;

public MovingRectangle(double x, double y, double vx,
        double vy, double width, double height) {

    this.x = x;
    this.y = y;
    this.vx = vx;
    this.vy = vy;
    this.isFrozen = false;
    this.halfWidth = width / 2;
    this.halfHeight = height / 2;


    rng = new Random();


    randomColor();
}

public void randomColor() {

    red = rng.nextInt(256);
    green = rng.nextInt(256);
    blue = rng.nextInt(256);
}

public void draw() {
    int a = rng.nextInt(4);

    if (isFrozen) {
        StdDraw.setPenColor(StdDraw.RED);
    } else {
        StdDraw.setPenColor(red, green, blue);
    }
    StdDraw.filledRectangle(x, y, halfWidth, halfHeight);
    StdDraw.setPenColor(StdDraw.BLACK);
    //StdDraw.text(x, y, "" + a);


    StdDraw.setPenRadius(0.01);
    StdDraw.setPenColor(StdDraw.BLACK);
    StdDraw.rectangle(x, y, halfWidth, halfHeight);
}

public void update() {
    if (isFrozen) {
        return;
    }


    x += vx;
    y += vy;


    if (x - halfWidth < 0) {
        vx *= -1;
        x = 0 + halfWidth;
        randomColor();
    }


    if (x + halfWidth > 1) {
        vx *= -1;
        x = 1 - halfWidth;
        randomColor();
    }


    if (y - halfHeight < 0) {
        vy *= -1;
        y = 0 + halfHeight;
        randomColor();
    }


    if (y + halfHeight > 1) {
        vy *= -1;
        y = 1 - halfHeight;
        randomColor();
    }
}

public void freeze() {

    isFrozen = true;
}

public void unfreeze() {
    if (!isFrozen) {
    return;
    }
    isFrozen = false;
}

public boolean isFrozen() {
    // returns true if the rectangle is frozen
    return isFrozen;
}

public boolean containsPoint(double a, double b) {
    // Returns true if and only if the point (a, b)
    // is contained inside the rectangle
    return a > x - halfWidth // left edge
             && a < x + halfWidth // right edge
             && b > y - halfHeight // bottom edge
             && b < y + halfHeight; // top edge
}
public int getX() {
    return (int) x;
}public int getY() {
    return (int) y;
}

public boolean collidesWith(MovingRectangle other)   {
    return x < other.x + other.halfWidth && x + halfWidth > other.x && y < other.y + 
            other.halfHeight && y + halfHeight > other.y;
} 
public boolean atSameLocation(MovingRectangle other) {
    return this.x == other.getX() && this.y == other.getY();
}
}
donkey brian
  • 29
  • 1
  • 4

2 Answers2

0

Keep track of the number of times the rectangle has been clicked within your MovingRectangle object class. You will want to reference that object data to determine if the freeze method should be called.

Your constructor for the MovingRectangle should initialize the number of clicks needed to freeze it to a value between 1 and 3.

To that end, you will need 'getters' and 'setters' within the MovingRectangle class for the counter that is keeping track of how many times the MovingRectangle needs to be clicked before it should freeze.

When your 'unfreeze' method is called on the MovingRectangle, reinitialize the counter to a random number between 1 and 3.

user681574
  • 553
  • 2
  • 15
0

I partially found a solution. It doesn't correctly store the amount of clicks needed to freeze and it doesn't correctly count one click, but other than that it mostly works. 

import java.util.Random;
public class Main {

public static void main(String[] args) {

    MovingRectangle[] rectangles = new MovingRectangle[5];


    Random rng = new Random();
    for (int i = 0; i < rectangles.length; i++) {
        rectangles[i] = new MovingRectangle(
                rng.nextDouble(), // x in [0, 1)
                rng.nextDouble(), // y in [0, 1)
                rng.nextDouble() * 0.02 - 0.01, // vx in [-0.01, 0.01)
                rng.nextDouble() * 0.02 - 0.01, // vy in [-0.01, 0.01)
                rng.nextDouble() * 0.2 + 0.1, // width in [0.1, 0.3)
                rng.nextDouble() * 0.2 + 0.1, // height in [0.1, 0.3)
                rng.nextInt(3) + 1
                );
    }

    while (true) {
        StdDraw.clear(StdDraw.GRAY);
         if (StdDraw.mousePressed()) {

    }
        // where check click status 

        int clickCount = 0;
        int clickStatus = 0;
        int frozenCount = 0;
        for (int i = 0; i < rectangles.length; i++) {
                if (StdDraw.mousePressed()) {
                    ++clickStatus;
                    if (clickStatus > 2) {
                        clickStatus = 2;
                    }
                } else {
                    clickStatus = 0;
                }
                if(clickStatus == 1) {
                clickCount++;
                clickCount = 3;
                }   


            if (StdDraw.mousePressed() 
                    && rectangles[i].containsPoint(StdDraw.mouseX(), StdDraw.mouseY())) {
                rectangles[i].setclicksRemaining();
                rectangles[i].freeze();
            }

            rectangles[i].draw();
            rectangles[i].update();

            if (rectangles[i].isFrozen()) {
                frozenCount++;
            }
            for (int j = i+1; j < rectangles.length; j++) {

                  if (rectangles[i].collidesWith(rectangles[j])) {

                    rectangles[i].unfreeze();
                    rectangles[j].unfreeze();
                    rectangles[i].draw();
                    rectangles[j].draw();
                  }
                }
        }
        StdDraw.setPenColor(StdDraw.WHITE);
        StdDraw.filledRectangle(0.2, 0.03, 0.2, 0.03);
        StdDraw.setPenColor(StdDraw.BLACK);
        StdDraw.textLeft(0.0, 0.03, "Rectangles remaining: " +
                (rectangles.length - frozenCount));


        if (frozenCount == rectangles.length) {
            StdDraw.setPenColor(StdDraw.WHITE);
            StdDraw.filledRectangle(0.5, 0.5, 0.1, 0.05);
            StdDraw.setPenColor(StdDraw.BLACK);
            StdDraw.text(0.5, 0.5, "You Win!");
        }
        StdDraw.show(25);
    }
}

}

import java.util.Random;

public class MovingRectangle {
Random rng;
private double x;
private double y;


private double vx;
private double vy;
private boolean isFrozen;
private boolean frozen;

private int red;
private int green;
private int blue;

private int clicksRemaining;

private double halfWidth;
private double halfHeight;




// Your constructor for the MovingRectangle should 
//initialize the number of clicks needed to freeze it to a value between 1 and 3.
public void clicksRemaining() {

    clicksRemaining = rng.nextInt(3) + 1;
}
public void setclicksRemaining() {
    if (clicksRemaining < 1) {
        clicksRemaining = 1;
    }
    --clicksRemaining;
}
public int getclicksRemaining() {
    return clicksRemaining;
}


public MovingRectangle(double x, double y, double vx,
        double vy, double width, double height, int clicksRemaining) {

    this.x = x;
    this.y = y;
    this.vx = vx;
    this.vy = vy;
    this.isFrozen = false;
    this.halfWidth = width / 2;
    this.halfHeight = height / 2;
    this.clicksRemaining = clicksRemaining;


    rng = new Random();


    randomColor();
}


public void randomColor() {

    red = rng.nextInt(256);
    green = rng.nextInt(256);
    blue = rng.nextInt(256);
}

public void draw() {

    if (isFrozen) {
        StdDraw.setPenColor(StdDraw.RED);
    } else {
        StdDraw.setPenColor(red, green, blue);
    }
    StdDraw.filledRectangle(x, y, halfWidth, halfHeight);
    StdDraw.setPenColor(StdDraw.BLACK);
    StdDraw.text(x, y, "" + clicksRemaining);


    StdDraw.setPenRadius(0.01);
    StdDraw.setPenColor(StdDraw.BLACK);
    StdDraw.rectangle(x, y, halfWidth, halfHeight);
}

public void update() {
    if (isFrozen) {
        return;
    }


    x += vx;
    y += vy;


    if (x - halfWidth < 0) {
        vx *= -1;
        x = 0 + halfWidth;
        randomColor();
    }


    if (x + halfWidth > 1) {
        vx *= -1;
        x = 1 - halfWidth;
        randomColor();
    }


    if (y - halfHeight < 0) {
        vy *= -1;
        y = 0 + halfHeight;
        randomColor();
    }


    if (y + halfHeight > 1) {
        vy *= -1;
        y = 1 - halfHeight;
        randomColor();
    }
}

public void freeze() {

    isFrozen = true;
}

public void unfreeze() {
    if (!isFrozen) {
    return;
    }
    clicksRemaining = rng.nextInt(3) + 1;
    isFrozen = false;
}

public boolean isFrozen() {
    return isFrozen;
}

public boolean containsPoint(double a, double b) {
    return a > x - halfWidth // left edge
             && a < x + halfWidth // right edge
             && b > y - halfHeight // bottom edge
             && b < y + halfHeight; // top edge
}
public int getX() {
    return (int) x;
}public int getY() {
    return (int) y;
}public int gethalfWidth() {
    return (int) halfWidth;
}public int gethalfHeight() {
    return (int) halfHeight;
}

public boolean collidesWith(MovingRectangle other)   {

    return x - halfWidth < other.x + other.halfWidth && x + halfWidth > other.x - other.halfWidth && y - halfHeight < other.y + 
            other.halfHeight && y + halfHeight > other.y - halfHeight;
}

}

donkey brian
  • 29
  • 1
  • 4