Thema: Java - Brauche hilfe

Hallo zusammen,

ich muss ein Java-Programm haben, welches einen Blitz zeichnet, von oben vom Fenster per Zufallsgenerator nach unten. Kann mir jemand helfen? Schön wäre noch ein Punkt Unten am Fenster, welchen den Blitz anzieht, d.h. dass der Blitz bei 10 mal ausführen etwa 7 mal in den Punkt einschlägt. Ich dachte mir irgendwie mit einem Koordinaten-System.
(P.S. über nicht all zu kompliziertes Java wäre ich sehr dankbar, da ich das Programm verstehen muss)

Herzlichen Dank,

Gruss triple

Hi,

die Aufgabe ist 80% Mathematik und 18% Logisches Denken und 2% in Java implementieren. Wo hakts? Ach und.. womit muesst ihr das machen? SWT? Swing?

Du meinst doch in etwa sowas, oder?

Hi,

danke für die Antwort, naja, swing, glaube ich, die Mathematik ist eigentlich kein Problem, die Logik auch nicht so sehr, aber mehr das Java-Programmieren.

Bin nun schon ziemlich weit, aber es hapert noch ein bisschen beim mehrfachen zeichnen, hier mein code, hoffentlich kannst du mir helfen.

Herzlichen Dank

Code:

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

public class PaintingLine extends JComponent {

	static int x, y, a = 1, xold, yold;

	public static void GetX() {
		int rand;
		xold = x;
		rand = (int) ((Math.random() * 100) + 50);
		if (x >= 650) {
			a = 2;
		} else if (x <= 150) {
			a = 1;
		}
		switch (a) {
		case 1:
			x = x + rand;
			a = 2;
			break;
		case 2:
			x = x - rand;
			a = 1;
			break;
		}
	}

	public static void GetY() {
		int rand;
		yold = y;
		rand = (int) ((Math.random() * 50) + 50);
		y = y + rand;
	}

	public PaintingLine() {
		super();
	}

	public void paint(Graphics g) {
		g.setColor(Color.BLACK);
		g.drawLine(xold, yold, x, y);
	}

	public static void main(String[] args) {
		x = 400;
		y = 0;
		JFrame f = new JFrame("Blitz");
		f.setSize(800, 600);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().add(new PaintingLine());
		f.setVisible(true);
		while (y <= 600) {
			GetX();
			GetY();
		}
	}
}

Oh, das sieht kompliziert zu berichtigen aus *g*

Ich habe mein Beispiel in SWT gemacht, aber in Swing sollte das nicht viel anders sein. Ich glaube nicht, dass es viel bringt, wenn ich meinen Code hier poste.. darum ein paar Tips. Wie dein Code aussieht, moechte ich behaupten, du kennst dich gut genug mit Java aus.. aber die vorgehensweise fuer was du ueberhaupt erstellen willst ist nicht 100% klar ;)

Zuerst.. wenn du oben links anfangen willst, dann sind die ersten Koordinaten 0,0. Wie brauchen pro Linie immer 2 Koordinaten/Punkte. Einmal fuer "Von" und einmal "Bis" - halt fuer Anfang und Ende einer Linie die wir zeichnen moechten. "Von" ist also (0,0). "Bis" musst du ausrechnen. Laenge habe ich statisch gewaehlt, 100 pixel oder so.. kommt auf die Aufgabenstellung drauf an ;)
Also, lt. Aufgabe.. erstelle einen random Winkel von 1-90 Grad (weil wir ja nur nach unten rechts wollen) ..mit Math.random(). Der Zielpunkt ist dann nach lustiger Trigonometrie (-> Wikipedia, Bild im Anhang in diesem Post) x = Cosinus(winkel), y = Sinus(winkel). In Java ausgedrueckt:

x = (int) (Math.abs(Math.cos(degree))*100);
y = (int) (Math.abs(Math.sin(degree))*100);

Nun, wo wir VON und BIS haben, zeichnen wir einen Linie dazwischen, mit der drawLine(x1, y1, x2, y2) Methode. Tadaa, erster Teil des Blitzes fertig.

Das Zeichnen muss natuerlich durch eine Schleife rennen, weil ein Blitz aus vielen Linien besteht, und wir fuer jeden Durchgang durch die Schleife neue VON und BIS Koordinaten brauchen. Meine Schleife ist statisch und macht 10 oder so Schritte fuer einen Blitz, aber du kannst natuerlich auch pruefen wie groß das Fenster ist usw.. aber erstmal das einfache Zeug machen.

In der Schleife: BIS wir nun zu VON, weil wir direkt weiterzeichnen wollen von wo wir aufgehoert haben. Das ist einfach. Fuer das neue BIS brauchen wir einen neuen random Winkel. Die Laenge bleibt, ausserdem musst du den alten Punkt dazurechnen, sonst gehts ja evtl wieder zurueck nach oben links. Also, in Java:

pTo.x = (int) (Math.abs(Math.cos(degree))*100) + pFrom.x;
pTo.y = (int) (Math.abs(Math.sin(degree))*100) + pFrom.y;

Das wars eigentlich schon.

Hier, so in etwa koennte die Paintmethode in Swing aussehen, mit statischer Laenge und doofer (aber einfacher) For-Schleife:

Code:

public void paint(Graphics g) {
	g.setColor(Color.BLACK);

	int degree = 1 + (int) (Math.random() * 90); 
	Point pFrom = new Point(0,0);
	Point pTo = new Point((int) (Math.abs(Math.cos(degree))*100),(int) (Math.abs(Math.sin(degree))*100));

	for (int i=0; i<12; i++) {

		g.drawLine(pFrom.x, pFrom.y, pTo.x, pTo.y);

		pFrom.x = pTo.x;
		pFrom.y = pTo.y;

		pTo.x = (int) (Math.abs(Math.cos(degree))*100) + pFrom.x;
		pTo.y = (int) (Math.abs(Math.sin(degree))*100) + pFrom.y;

		degree = 1 + (int) (Math.random() * 90); 
	}
}

Oh btw, bin seit dem 16.03. Registriert, d.h. ich verschwende nun seit 1 Jahr und 1 Tag meine Zeit mit Forumla, wenn das mal kein Grund zu Feiern is >_<

Hi Mire,

danke für die Antwort, du hast mir geholfen, ohne dass du es dort gewollt hast.

Ich starte primär von der Mitt oben, daher die Koordinaten 400, 0 (Fenstergrösse 800 Pixel) und gehe danach gerade nach unten, also mehr ein "reality-blitz". Aber habe dank deiner Antwort mein fehler Gefunden, habe die Schlauf ins Main reingetan anstatt in die paint-methode. nun funktionierts eigentlich ganz gut, hier mein code mit dem Resultat, welches ich so in etwa wollte.
Achja, ich habe es ohne Grad und länge gemacht, sondern zufallszahlen, welche die neuen Koordinaten beinhalten.

Gruss triple

Code:

package point;

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

public class PaintingLine extends JComponent {

	static int x, y, a = 1, xold, yold;

	public static void GetX() {
		int rand;
		xold = x;
		rand = (int) ((Math.random() * 100) + 25);
		if (x >= 650) {
			a = 2;
		} else if (x <= 150) {
			a = 1;
		}
		switch (a) {
		case 1:
			x = x + rand;
			a = 2;
			break;
		case 2:
			x = x - rand;
			a = 1;
			break;
		}
	}

	public static void GetY() {
		int rand;
		yold = y;
		rand = (int) ((Math.random() * 25) + 25);
		y = y + rand;
		if (y < 0) {
			y = 0;
		}
	}

	public PaintingLine() {
		super();
	}

	public void paint(Graphics g) {
		g.setColor(Color.BLACK);
		while (y <= 600) {
			GetX();
			GetY();
			g.drawLine(xold, yold, x, y);
		}
	}

	public static void main(String[] args) {
		x = 400;
		y = 0;
		JFrame f = new JFrame("Blitz");
		f.setSize(800, 600);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().add(new PaintingLine());
		f.setVisible(true);
	}
}

Sieht doch gut aus ;)

Winkel brauchst du auch nicht wenn du nur von oben nach unten willst, stimmt.

Allerdings geht dein Blitz kaputt sobald man ihn neuzeichnen laesst. Wie zB durch Fenstergroeße veraendern usw. Das kannst du dadurch verhindern, dass du die y Koordinate wieder auf 0 Setzt, sobald alles fertig ist. Also hier:

Code:

	public void paint(Graphics g) {
		g.setColor(Color.BLACK);
		while (y <= 600) {
			GetX();
			GetY();
			g.drawLine(xold, yold, x, y);
		}
y = 0; // <---------
	}

PS: In welcher Klasse macht man sowas heutzutage? *g*

Ja stimmt, hast recht, nur, das problem ist, ich muss dann die Fenstergrösse irgendwie dynamisch als untere Grenze definieren, aber dafür bin ich DEFEÌNITIV zu schlecht in java, denn wenn ich das Fenster vergrössere, geht der Blitz nur bis 600 Pixel.

Weisst du wie das geht? Naja, ich könnte auch bei 550 Pixel eine Linie als "Boden" machen, dann wäre das Problem gelöst.

Gruss triple

triple

Ja stimmt, hast recht, nur, das problem ist, ich muss dann die Fenstergrösse irgendwie dynamisch als untere Grenze definieren, aber dafür bin ich DEFEÌNITIV zu schlecht in java, denn wenn ich das Fenster vergrössere, geht der Blitz nur bis 600 Pixel.

Weisst du wie das geht? Naja, ich könnte auch bei 550 Pixel eine Linie als "Boden" machen, dann wäre das Problem gelöst.

Gruss triple

Eine noch einfachere Loesung als die Linie waere, du setzt fest, dass das Fenster nicht "resized" werden darf und eventuell "always on top" ;)

Code:

f.setResizable(false);
f.setAlwaysOnTop(true);

Das mit der Linie, oder noch besser, ein gefuelltes Rechteck.. geht natuerlich auch. Wenn du das ganze je nach Fenstergroeße machen willst, ist eine kleine aber grundlegende Aenderung noetig: Du musst den JFrame den du erstellst, weitergeben.

Code:

f.getContentPane().add(new PaintingLine(f));

..da der natuerlich auch irgendwo verbleiben muss, muss der Konstruktor das wissen, und eine Variable (namens wuwu!) her:

Code:

public class PaintingLine extends JComponent {

	static int x, y, a = 1, xold, yold;
	JFrame wuwu;

Code:

public PaintingLine(JFrame wuwu) {
	super();
	this.wuwu = wuwu;
}

Dann kannst du in der Paintmethode die groeße verwenden wie du willst:

Code:

g.drawString("Hoehe: " + String.valueOf(wuwu.bounds().height), 100, 100);
g.drawString("Breite: " + String.valueOf(wuwu.bounds().width), 100, 112);

Edit: Abschließend nochmal alles zusammen :p
Swing:

Code:

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

public class PaintingLine extends JComponent {

	static int x, y, a = 1, xold, yold;
	JFrame wuwu;

	public static void GetX() {
		int rand;
		xold = x;
		rand = (int) ((Math.random() * 100) + 25);
		if (x >= 650) {
			a = 2;
		} else if (x <= 150) {
			a = 1;
		}
		switch (a) {
		case 1:
			x = x + rand;
			a = 2;
			break;
		case 2:
			x = x - rand;
			a = 1;
			break;
		}
	}

	public static void GetY() {
		int rand;
		yold = y;
		rand = (int) ((Math.random() * 25) + 25);
		y = y + rand;
		if (y < 0) {
			y = 0;
		}
	}
	
	public static int col() {
		return (int) (Math.random() *256);
	}

	public PaintingLine(JFrame wuwu) {
		super();
		this.wuwu = wuwu;
	}

	public void paint(Graphics g) {

//		g.drawString("Hoehe: " + String.valueOf(wuwu.bounds().height), 100, 100);
//		g.drawString("Breite: " + String.valueOf(wuwu.bounds().width), 100, 112);
		
		for (int i=0; i<10; i++) {
			g.setColor(new Color(col(), col(), col()));
		while (y <= wuwu.bounds().height) {
			GetX();
			GetY();
			g.drawLine(xold, yold, x, y);
		} y = 0 ; x = wuwu.bounds().width / 2;
		}
	}

	public static void main(String[] args) {
		x = 400;
		y = 0;
		JFrame f = new JFrame("Blitz");
		f.setSize(800, 600);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().add(new PaintingLine(f));
		f.setVisible(true);
	}
}

SWT:

Code:

import org.eclipse.swt.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.layout.*;

public class blitz {

	public void run() {
		Display display = new Display();
		Shell shell = new Shell(display);
		shell.setText("Test");
		createContents(shell);
		shell.open();
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch()) {
				display.sleep();
			}
		}
		display.dispose();
	}

	private void createContents(Shell shell) {
		shell.setLayout(new FillLayout());

		Canvas canvas = new Canvas(shell, SWT.NONE);

		canvas.addPaintListener(new PaintListener() {
			public void paintControl(PaintEvent e) {

				e.gc.setLineWidth(3);
				for (int i=1; i<10; i++) { drawBlitz(e); }
			}
		});
	}

	public static void drawBlitz(PaintEvent e) {      

		e.gc.setForeground(e.display.getSystemColor(1+(int)(Math.random()*16)));
		
		int degree = 1 + (int) (Math.random() * 90); 
		Point pFrom = new Point(0,0);
		Point pTo = new Point((int) (Math.abs(Math.cos(degree))*100),(int) (Math.abs(Math.sin(degree))*100));

		for (int i=0; i<12; i++) {

			e.gc.drawLine(pFrom.x, pFrom.y, pTo.x, pTo.y);

			pFrom.x = pTo.x;
			pFrom.y = pTo.y;

			pTo.x = (int) (Math.abs(Math.cos(degree))*100) + pFrom.x;
			pTo.y = (int) (Math.abs(Math.sin(degree))*100) + pFrom.y;

			degree = 1 + (int) (Math.random() * 90); 
		}
	}

	public static void main(String[] args) {
		new blitz().run();
	}
}

@Mire

Herzlichen Dank, das hat mir sehr geholfen, ich denke so ist das machbar.

Nochmals, danke viel mal.

Gruss triple