Object Kreis am Frame abprallen lassen!

[Zitrus]

Hallo erstmal,

Ich habe eine Extraaufgabe vom Lehrer bekommen undzwar soll ich ein Kreis bei Berührung mit dem Frame abprallen lassen.

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

public class Kreis
{
    private int diameter;
	private int xPosition;
	private int yPosition;
	private String color;
	private boolean isVisible;

    Kreis()
    {
		// Weise den Attributen hier Werte zu.
		xPosition = 250;
		yPosition = 300;
		color = "yellow";
		isVisible = true;
		diameter = 50;
		draw();
    }
    
    public void setPosition(int newxPosition, int newY)
    {
        erase();
        xPosition = newxPosition;
        yPosition = newY;
        draw();
    }

    public void moveHorizontal(int distance)
    {
		erase();
		xPosition += distance;
		draw();
    }

    public void moveVertical(int distance)
    {
		erase();
		yPosition += distance;
	   	draw();
    }
    
    public void staendigeBewegung(char x_richtung,char y_richtung ) 
    {  
        int bewegung_x = 1;
        int bewegung_y = 1;      
        while (true) {
            if (xPosition >= 500 || xPosition <= 0) 
            {
                 bewegung_x = (bewegung_x) * -1;
            }
        
            if (yPosition >= 500 || yPosition <= 0) 
            {
                 bewegung_y = (bewegung_y) * -1;
            }
            
            if (x_richtung == '-') {
                bewegung_x = (xPosition -= 1);
            }
            else if (x_richtung == '+') {
                bewegung_x = (xPosition += 1);
            }
            else 
            {
                System.out.println("Bitte wähle zwischen '+' und '-' !");
                break;
            }
        
            if (y_richtung == '-') {
                bewegung_y = yPosition -= 1;
            }
            else if (y_richtung == '+') {
                bewegung_y = yPosition += 1;
            }
            else {
                System.out.println("Bitte wähle zwischen '+' und '-' !");
                break;
            }
            draw();
        }
        
    }
  
    
    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();
			}
    }

    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();
		}
    }

    public void changeSize(int newDiameter)
    {
		erase();
		diameter = newDiameter;
		draw();
    }

    public void changeColor(String newColor)
    {
		color = newColor;
		draw();
    }

	private void draw()
	{
		if(isVisible) {
			Canvas canvas = Canvas.getCanvas();
			canvas.draw(this, color, new Ellipse2D.Double(xPosition, yPosition, 
														  diameter, diameter));
			canvas.wait(10);
		}
	}

	private void erase()
	{
		if(isVisible) {
			Canvas canvas = Canvas.getCanvas();
			canvas.erase(this);
		}
	}
}

Die Methode dich ich geschrieben hab ist staendigeBewegung. Es funktioniert jedoch nicht mit dem Abprallen.. Kann mir da jemand helfen bzw. sagen was falsch ist?

Vielen Dank schonmal im Vorraus!

Mfg, xZitrus

 

[Bug Fisher]

Sieht auf den ersten Blick nicht so falsch aus, was genau geht denn nicht ?

 

[Zitrus]

Naja es prallt nicht an dem Frame ab

 

[Bug Fisher]

Sondern !?

 

[Zitrus]

Oh entschuldige, dass ich das nicht oben dazu geschrieben habe^^ Der Kreis bewegt sich einfach weiter in die Richtung die ich am Anfang durch die chars bestimmt habe.

 

[Bug Fisher]

Du änderst in staendigeBewegung() zwar (richtig) die dx, dy; also bewegung_x und bewegung_y, du vergisst aber, xPosition und yPosition entsprechend zu aktualisieren vor dem draw !

 

[Zitrus]

Mit

bewegung_x = (bewegung_x) * -1;

änder ich die bewegungsrichtung in die entgegengesetzte also wenn davor bewegung_x = xPosition + 1;
dann wird das zu: bewegung_x = xPosition -1;

Habe ich das falsch verstanden?

 

[AndiE]

Hallo,

ich kann die Funktioen nicht nachvollziehen. Kannst du mal alles posten?

 

[Zitrus]

Class Canvas (vorgegeben)

import javax.swing.*;
import java.awt.*;
import java.util.List;
import java.util.*;

/**
 * Canvas is a class to allow for simple graphical drawing on a canvas.
 * This is a modification of the general purpose Canvas, specially made for
 * the BlueJ "shapes" example. 
 *
 * @author: Bruce Quig
 * @author: Michael Kolling (mik)
 *
 * @version: 1.6 (shapes)
 */
public class Canvas
{
    // Note: The implementation of this class (specifically the handling of
    // shape identity and colors) is slightly more complex than necessary. This
    // is done on purpose to keep the interface and instance fields of the
    // shape objects in this project clean and simple for educational purposes.

	private static Canvas canvasSingleton;

	/**
	 * Factory method to get the canvas singleton object.
	 */
	public static Canvas getCanvas()
	{
		if(canvasSingleton == null) {
			canvasSingleton = new Canvas("BlueJ Shapes Demo", 500, 500, 
										 Color.white);
		}
		canvasSingleton.setVisible(true);
		return canvasSingleton;
	}

	//  ----- instance part -----

    private JFrame frame;
    private CanvasPane canvas;
    private Graphics2D graphic;
    private Color backgroundColour;
    private Image canvasImage;
    private List objects;
    private HashMap shapes;
    
    /**
     * Create a Canvas.
     * @param title  title to appear in Canvas Frame
     * @param width  the desired width for the canvas
     * @param height  the desired height for the canvas
     * @param bgClour  the desired background colour of the canvas
     */
    private Canvas(String title, int width, int height, Color bgColour)
    {
        frame = new JFrame();
        canvas = new CanvasPane();
        frame.setContentPane(canvas);
        frame.setTitle(title);
        canvas.setPreferredSize(new Dimension(width, height));
        backgroundColour = bgColour;
        frame.pack();
        objects = new ArrayList();
        shapes = new HashMap();
    }

    /**
     * Set the canvas visibility and brings canvas to the front of screen
     * when made visible. This method can also be used to bring an already
     * visible canvas to the front of other windows.
     * @param visible  boolean value representing the desired visibility of
     * the canvas (true or false) 
     */
    public void setVisible(boolean visible)
    {
        if(graphic == null) {
            // first time: instantiate the offscreen image and fill it with
            // the background colour
            Dimension size = canvas.getSize();
            canvasImage = canvas.createImage(size.width, size.height);
            graphic = (Graphics2D)canvasImage.getGraphics();
            graphic.setColor(backgroundColour);
            graphic.fillRect(0, 0, size.width, size.height);
            graphic.setColor(Color.black);
        }
        frame.setVisible(visible);
    }

    /**
     * Draw a given shape onto the canvas.
     * @param  referenceObject  an object to define identity for this shape
     * @param  color            the color of the shape
     * @param  shape            the shape object to be drawn on the canvas
     */
     // Note: this is a slightly backwards way of maintaining the shape
     // objects. It is carefully designed to keep the visible shape interfaces
     // in this project clean and simple for educational purposes.
    public void draw(Object referenceObject, String color, Shape shape)
    {
    	objects.remove(referenceObject);   // just in case it was already there
    	objects.add(referenceObject);      // add at the end
    	shapes.put(referenceObject, new ShapeDescription(shape, color));
    	redraw();
    }
 
    /**
     * Erase a given shape's from the screen.
     * @param  referenceObject  the shape object to be erased 
     */
    public void erase(Object referenceObject)
    {
    	objects.remove(referenceObject);   // just in case it was already there
    	shapes.remove(referenceObject);
    	redraw();
    }

    /**
     * Set the foreground colour of the Canvas.
     * @param  newColour   the new colour for the foreground of the Canvas 
     */
    public void setForegroundColor(String colorString)
    {
		if(colorString.equals("red"))
			graphic.setColor(Color.red);
		else if(colorString.equals("black"))
			graphic.setColor(Color.black);
		else if(colorString.equals("blue"))
			graphic.setColor(Color.blue);
		else if(colorString.equals("yellow"))
			graphic.setColor(Color.yellow);
		else if(colorString.equals("green"))
			graphic.setColor(Color.green);
		else if(colorString.equals("magenta"))
			graphic.setColor(Color.magenta);
		else if(colorString.equals("white"))
			graphic.setColor(Color.white);
		else
			graphic.setColor(Color.black);
    }

    /**
     * Wait for a specified number of milliseconds before finishing.
     * This provides an easy way to specify a small delay which can be
     * used when producing animations.
     * @param  milliseconds  the number 
     */
    public void wait(int milliseconds)
    {
        try
        {
            Thread.sleep(milliseconds);
        } 
        catch (Exception e)
        {
            // ignoring exception at the moment
        }
    }

	/**
	 * Redraw ell shapes currently on the Canvas.
	 */
	private void redraw()
	{
		erase();
		for(Iterator i=objects.iterator(); i.hasNext(); ) {
            ((ShapeDescription)shapes.get(i.next())).draw(graphic);
        }
        canvas.repaint();
    }
       
    /**
     * Erase the whole canvas. (Does not repaint.)
     */
    private void erase()
    {
        Color original = graphic.getColor();
        graphic.setColor(backgroundColour);
        Dimension size = canvas.getSize();
        graphic.fill(new Rectangle(0, 0, size.width, size.height));
        graphic.setColor(original);
    }


    /************************************************************************
     * Inner class CanvasPane - the actual canvas component contained in the
     * Canvas frame. This is essentially a JPanel with added capability to
     * refresh the image drawn on it.
     */
    private class CanvasPane extends JPanel
    {
        public void paint(Graphics g)
        {
            g.drawImage(canvasImage, 0, 0, null);
        }
    }
    
    /************************************************************************
     * Inner class CanvasPane - the actual canvas component contained in the
     * Canvas frame. This is essentially a JPanel with added capability to
     * refresh the image drawn on it.
     */
    private class ShapeDescription
    {
    	private Shape shape;
    	private String colorString;

		public ShapeDescription(Shape shape, String color)
    	{
    		this.shape = shape;
    		colorString = color;
    	}

		public void draw(Graphics2D graphic)
		{
			setForegroundColor(colorString);
			graphic.fill(shape);
		}
    }

}

Class Kreis (zum Großteil vorgegeben)

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

public class Kreis
{
    private int diameter;
	private int xPosition;
	private int yPosition;
	private String color;
	private boolean isVisible;

    Kreis()
    {
		// Weise den Attributen hier Werte zu.
		xPosition = 250;
		yPosition = 300;
		color = "yellow";
		isVisible = true;
		diameter = 50;
		draw();
    }
    
    public void setPosition(int newxPosition, int newY)
    {
        erase();
        xPosition = newxPosition;
        yPosition = newY;
        draw();
    }

    public void moveHorizontal(int distance)
    {
		erase();
		xPosition += distance;
		draw();
    }

    public void moveVertical(int distance)
    {
		erase();
		yPosition += distance;
	   	draw();
    }
    
    public void staendigeBewegung(char x_richtung,char y_richtung ) 
    {  
        int bewegung_x = 1;
        int bewegung_y = 1;      
        while (true) {
            if (x_richtung == '-') {
                bewegung_x = xPosition -= 1;
            }
            else if (x_richtung == '+') {
                bewegung_x = xPosition += 1;
            }
            else 
            {
                System.out.println("Bitte wähle zwischen '+' und '-' !");
                break;
            }
        
            if (y_richtung == '-') {
                bewegung_y = yPosition -= 1;
            }
            else if (y_richtung == '+') {
                bewegung_y = yPosition += 1;
            }
            else {
                System.out.println("Bitte wähle zwischen '+' und '-' !");
                break;
            }
            
            if (xPosition >= (500 - diameter) || xPosition <= 0) 
            {
                 bewegung_x = (bewegung_x) * -1;
            }
        
            if (yPosition >= (500 - diameter) || yPosition <= 0) 
            {
                 bewegung_y = (bewegung_y) * -1;
            }
            draw();
        }     
    }
  
    
    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();
			}
    }

    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();
		}
    }

    public void changeSize(int newDiameter)
    {
		erase();
		diameter = newDiameter;
		draw();
    }

    public void changeColor(String newColor)
    {
		color = newColor;
		draw();
    }

	private void draw()
	{
		if(isVisible) {
			Canvas canvas = Canvas.getCanvas();
			canvas.draw(this, color, new Ellipse2D.Double(xPosition, yPosition, 
														  diameter, diameter));
			canvas.wait(10);
		}
	}

	private void erase()
	{
		if(isVisible) {
			Canvas canvas = Canvas.getCanvas();
			canvas.erase(this);
		}
	}
}

Bug Fischer sagte ja bereits, dass ich die xPosition und yPosition aktualisiern muss. Weiß aber nicht genau wie...

 

[AndiE]

Das mag ja sein, aber wo geht dein Programm los? Wo wird "staendigeBewegung" aufgerufen? Ich kann das nicht sehen.

 

[Zitrus]

Anhang anzeigen 7173

Ich hoffe mit dem Bild ist es etwas verständlicher für dich. Ausserdem habe ich das Problem schon gelöst undzwar so:

public void staendigeBewegung(char x_richtung,char y_richtung ) 
    {    
        while (true) {
            if (x_richtung == '-') {
                xPosition -= 1;
            }
            else if (x_richtung == '+') {
                xPosition += 1;
            }
            else 
            {
                System.out.println("Bitte wähle zwischen '+' und '-' !");
                break;
            }
        
            if (y_richtung == '-') {
                yPosition -= 1;
            }
            else if (y_richtung == '+') {
                yPosition += 1;
            }
            else {
                System.out.println("Bitte wähle zwischen '+' und '-' !");
                break;
            }
            
            if (xPosition == (500 - diameter) || xPosition == 0) 
            {
                if (x_richtung == '-') {
                    x_richtung = '+';
                }
                else if  (x_richtung == '+') {
                    x_richtung = '-';
                }
            }
        
            if (yPosition == (500 - diameter) || yPosition == 0) 
            {
                if (y_richtung == '-') {
                    y_richtung = '+';
                }
                else if (y_richtung == '+') {
                    y_richtung = '-';
                }
            }
            draw();
        }     
    }

Nur möchte ich das jetzt bisschen abwandeln undzwar so, dass die Methode nur die xPosition, yPosition checkt und falls ja, dann soll es die Bewegung quasi "umdrehen".

 

[arilou]

Ich würde die Fälle
if( xPosition >= (500-diameter) )
und
if( xPosition <= 0)
auseinanderziehen; dann kannst du einfach sagen: "In dem Fall wird x_richtung='-'"
bzw. "In dem Fall wird x_richtung='+'". Macht die Sache schon mal stabiler. Und ">=" und "<=" ebenfalls.

Für deine Abwandlung: Nimm doch die Parameter
char x_richtung,char y_richtung
aus dem Methodenkopf, und initialisiere sie einfach selbst mit gültigen Werten ('+','+').

 

[Zitrus]

Vielen Dank arilou habe nicht vermutet, dass mir vor Donnerstag noch jemand antwortet! Werde es dann Morgen oder übermorgen umsetzen (Habe zurzeit viele Prüfungen)

Mit freundlichen Grüßen
Zitrus