I really need help, my 1st assigment is due tomorrow and i've been working on it for a really long time and is just not getting it!!!!

So please help me, it will be greatly appreciated.

These are the questions that I haven't been able to figure out.

Add a new method called shuffleHorizontal that takes a single integer as its argument. When invoked, the method causes the circle to do a slow shuffle to the right by the specified number of pixels, then back to the left, leaving the circle exactly where it started. (That's assuming the input is positive — if the input is negative, the circle will shuffle left, then right.) Add a comment describing your new method. Hint: If your solution is more than a few lines long, you've made this more difficult than it needs to be!

Optional: Modify the code so that circles are visible (on the screen) when they're first created. (No extra points for this one, but completing it will produce a profound sense of well being.)

And here is the code

import java.awt.*;
import java.awt.geom.*;

/**
 * A circle that can be manipulated and that draws itself on a canvas.
 * 
 * @author  Michael Kolling and David J. Barnes and Tiana Orta
 * @version 2008.03.30
 */

public class Circle
{
    private int diameter;
    private int xPosition;
    private int yPosition;
    private String color;
    private boolean isVisible;
    
    /**
     * Create a new circle at default position with default color.
     */
    public Circle()
    {
        diameter = 30;
        xPosition = 20;
        yPosition = 60;
        color = "yellow";
        isVisible = false;
    }

    /**
     * Make this circle visible. If it was already visible, do nothing.
     */
    public void makeVisible()
    {
        isVisible = true;
        draw();
    }
    
    /**
     * Make this circle invisible. If it was already invisible, do nothing.
     */
    public void makeInvisible()
    {
        erase();
        isVisible = false;
    }
    
    /**
     * Move the circle a few pixels to the right.
     */
    public void moveRight()
    {
        moveHorizontal(30);
    }

    /**
     * Move the circle a few pixels to the left.
     */
    public void moveLeft()
    {
        moveHorizontal(-30);
    }

    /**
     * Move the circle a few pixels up.
     */
    public void moveUp()
    {
        moveVertical(-30);
    }

    /**
     * Move the circle a few pixels down.
     */
    public void moveDown()
    {
        moveVertical(30);
    }
    
     /**
     * Move the circle a few pixels up and right (NorthEast).
     */
    public void moveNorthEast()
    {
        moveVertical(-30); moveHorizontal(30); 
    }

       /**
     * Move the circle horizontally by 'distance' pixels.
     */
    public void moveHorizontal(int distance)
    {
        erase();
        xPosition += distance;
        draw();
    }
    
    /**
     * Move the circle vertically by 'distance' pixels.
     */
    public void moveVertical(int distance)
    {
        erase();
        yPosition += distance;
        draw();
    }

    /**
     * Slowly move the circle horizontally by 'distance' pixels.
     */
    public void slowMoveHorizontal(int distance)
    {
        int delta;

        if(distance < 0) 
        {
            delta = -1;
            distance = -distance;
        }
        else 
        {
            delta = 1;
        }

        for(int i = 0; i < distance; i++)
        {
            xPosition += delta;
            draw();
        }
    }

    /**
     * Slowly move the circle vertically by 'distance' pixels.
     */
    public void slowMoveVertical(int distance)
    {
        int delta;

        if(distance < 0) 
        {
            delta = -1;
            distance = -distance;
        }
        else 
        {
            delta = 1;
        }

        for(int i = 0; i < distance; i++)
        {
            yPosition += delta;
            draw();
        }
    }
     
    /**
     * Slowly move the circle vertically by 'distance' pixels.
     */
    public void shuffleHorizontal(int distance)
    {
        int delta;

        if(distance < 0) 
        {
            delta = -1;
            distance = -distance;
        }
        
        {
            delta = 1;
        }

        for(int i = 0; i < distance; i++)
        {
            xPosition += delta;
            draw();
            erase();
            xPosition += -delta;
            draw();
        }
    }
    
    /**
     * Change the size to the new size (in pixels). Size must be >= 0.
     */
    public void changeSize(int newDiameter)
    {
        erase();
        diameter = newDiameter;
        draw();
    }

    /**
     * Change the color. Valid colors are "red", "yellow", "blue", "green",
     * "magenta" and "black".
     */
    public void changeColor(String newColor)
    {
        color = newColor;
        draw();
    }

    /**
     * Draw the circle with current specifications on screen.
     */
    private void draw()
    {
        if(isVisible) {
            Canvas canvas = Canvas.getCanvas();
            canvas.draw(this, color, new Ellipse2D.Double(xPosition, yPosition, 
                                                          diameter, diameter));
            canvas.wait(10);
        }
    }

    /**
     * Erase the circle on screen.
     */
    private void erase()
    {
        if(isVisible) {
            Canvas canvas = Canvas.getCanvas();
            canvas.erase(this);
        }
    }
}

Edited 5 Years Ago by Ezzaral: Added code tags. Please use them to format any code that you post.

Post your code using CODE tags.
You also have not told us your problem. Do you have any parts working? Which part/parts are you having trouble with? Are there any compile errors?

Edited 3 Years Ago by happygeek: fixed formatting

sorry I'm new to this

so i'm not having problems with the code that is up there so far, but I need to add to this code a method that does the following:

Add a new method called shuffleHorizontal that takes a single integer as its argument. When invoked, the method causes the circle to do a slow shuffle to the right by the specified number of pixels, then back to the left, leaving the circle exactly where it started. (That's assuming the input is positive — if the input is negative, the circle will shuffle left, then right.) Add a comment describing your new method. Hint: If your solution is more than a few lines long, you've made this more difficult than it needs to be!

thank you!

Edited 5 Years Ago by 09tikimo: n/a

This article has been dead for over six months. Start a new discussion instead.