Wie kontakt von 2 gezeichneten Rechtecken feststellen?

Status
Nicht offen für weitere Antworten.

NatroN

Aktives Mitglied
Wie sicher schon viele mitbekommen haben, arbeite ich an einem Spiel.

Das nun sicher größte Problem erfordert euer Hirnschmalz und etwas ehrgeiz. ich habe mich schon etwas umgehört, bin aber auf noch keine zufriedenstellende lösung gekommen.

Es soll festfestellt werden ob das Volle Viereck (das in der geschw. geregelt werden kann) eines der leeren Vierecke berührt.

SO SCHAUTS IM MOMENT AUS

und hier ist der Code in dem das meiste errechnet und gezeichnet wird

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


public class JStrassen extends JPanel
{

   private boolean run;
   private int  speed = 0;
   private int zaehler;
   private int schrittweite;
   private double xWert;
	 private double yWert;
	 private double steigung;
	 private int zufall;

	 private double	verkehr1=(Math.random()*30);
	 private double	verkehr2=((verkehr1+60)+Math.floor(Math.random()*(200-verkehr1+61)));
	 private double	verkehr3=((verkehr2+60)+Math.floor(Math.random()*(200-verkehr2+61)));
	 private double	verkehr4	=((verkehr3+60)+Math.floor(Math.random()*(200-verkehr3+61)));
//u + Math.floor(Math.random() * (o-u+1))
  public JStrassen (int zaehler, boolean run, int  speed)
  {
    setZaehler (zaehler);
    setRunB (run);
    setSpeed (speed);

  }


  public void setZaehler (int zaehler )
  {
	this.zaehler = zaehler;
  }






  public void setRunB (boolean run )
  {
    this.run = run;
  }



  public void setSpeed (int  speed)
  {
    this.speed = speed;
  }




  public void paintComponent (Graphics screen)
  {	Graphics2D screen2d = (Graphics2D) screen;
		zufall=(int)(Math.random()*10);
		/** Die Straße wird gezeichnet.
 		*/


			screen.setColor(new Color(155,155,155));		//Das grau für die Straße
  	//screen.fillRect(0,150,800,60);							//Der gerade Straßenteil
  	//screen.fillArc(400,150,600,540,90,90);			//Die Kurve
  		screen.setColor(new Color(255,255,255));
  		screen.fillArc(460,210,540,480,90,90);
			screen.setColor(new Color(0,0,0));
		//screen.fillOval(515,224,5,5); //Der Schnittpunkt
		//screen.fillOval(700,178,5,5); //Der Schnittpunkt
			screen.drawString(verkehr1 + " " + verkehr2 + " " + verkehr3 + " " + verkehr4,120,40);
		//Autos zeichnen


		screen.drawRect(((int)(-verkehr1+(zaehler*5))),180, 50,20);
		screen.drawRect(((int)(-verkehr2+(zaehler*5))),180,50,20);
		screen.drawRect(((int)(-verkehr3+(zaehler*5))),180,50,20);
		screen.drawRect(((int)(-verkehr4+(zaehler*5))),180,50,20);
	//Berechnen der Werte für den Punkt
		xWert = schrittweite;
			if(schrittweite<515) //Bevor die Kurve gefahren wird
				{yWert = -0.53018867924528301886792452830189*xWert + 505;
	 	//		 screen.fillOval((int)xWert-2, (int)yWert-2,4,4);
	 			 steigung=(-0.53018867924528301886792452830189);
				 screen2d.rotate(steigung,(int)xWert,(int)yWert);
				 screen.fillRect((int)xWert,(int)yWert,50,20);
				 screen2d.rotate(-steigung,(int)xWert,(int)yWert);
	 			 screen.drawString("Steigung: "+zufall,120,30);
				}
			else
				{	if (schrittweite>700) //nachdem die Kurve gefahren wurde
				 		{yWert= 180;
			//	 	   screen.fillOval((int)xWert-2, (int)yWert-2,4,4);
				 		 steigung=0;
						 screen2d.rotate(steigung,(int)xWert,(int)yWert);
						 screen.fillRect((int)xWert,(int)yWert,50,20);
						 screen2d.rotate(-steigung,(int)xWert,(int)yWert);
	 			 		 screen.drawString("Steigung: "+steigung,120,30);
				  	}
	   		 	else //die Kurve
						{yWert=0.001463*(xWert*xWert)-2.034*xWert+887.199;
	//					 screen.fillOval((int)xWert-2, (int)yWert-2,4,4);
						 steigung=2*0.001464*(xWert)-2.034;
						 screen2d.rotate(steigung,(int)xWert,(int)yWert);
						 screen.fillRect((int)xWert,(int)yWert,50,20);
						 screen2d.rotate(-steigung,(int)xWert,(int)yWert);
	 			 		 screen.drawString("Steigung: "+steigung,120,30);
						}
			 }

		/**
		Hier wird die Geschwindigkeit des Autos verändert
		**/
		if(run==true)
		schrittweite += speed;

  	if((schrittweite>1000))
  		schrittweite = 0;



// Für Testzwecke werden einige Werte dargestellt
  	//screen.fillRect (20+(schrittweite),20,20,20);
    screen.drawString("Zaehler:"+ zaehler + "Speed: " + speed+"Zaehler1:" + schrittweite, 120,120);

		screen.drawString("XWert: "+xWert + "yWert: "+yWert,120,150);

  }

}

Daweil ist alles irgendwie in die graphics gepfercht... eben nur aus Testzwecken.. das wird aber im Moment behoben.

mfg
 

NatroN

Aktives Mitglied
was genau sagt mir das? Werde dann gleich in der api nachschaun.. aber davon hab ich nie was gehört und weiß net wie ich das anwenden muss.

Mfg
 

AlArenal

Top Contributor
Ich würde ja erst in der API nachschauen, sehen was ich mit der neuen Info anfangen kann und mich dann bei Rückfragen zu Wort melden....
 

NatroN

Aktives Mitglied
hab die docu durchgegraben (leider hatte ich früher keine zeit dazu)

also ich hab mal nach rectanlge gesucht... ...auch gefunden und sie hat auch eine intersects

intersects(Rectangle r)
Determines whether or not this Rectangle and the specified Rectangle intersect.

Nun verstehe ich aber nicht wie ich das bei mir anwenden kann?!
die rechtecke werden nur mit drawRect in der Paint gezeichnet...

bin bereit das auch anders zu lösen, wenn man mir sagt wie :)

vielen vielen dank schon mal an euch
 

Wildcard

Top Contributor
Anstatt die Rechtecke nur zu zeichnen musst du eben Rectangle Objekte erstellen und diese dann zeichnen.
 

NatroN

Aktives Mitglied
ich bin gerade dabei, eine klasse für die fahzeuge zu schreiben..

da kann ich da vielleicht sowas einbinden...

wie macht man rectangle objekte?! Hast da ein anschauungsbeispiel oder kannst ma in ein paar zeilen code das schnell zeigen?!

mfg
 
B

Beni

Gast
Rechtecke:
Code:
Rectangle rec = new Rectangle( 1, 2, 3, 4);

:wink:
 
B

Beni

Gast
Code:
Rectangle rec = ...
Graphics g = ...
g.drawRect( rec.x, rec.y, rec.width, rec.height);
...
 

NatroN

Aktives Mitglied
hab jetzt endlich wieder ein paar minuten zeit gehbatt

Also hab jetzt rectangle objekte und die werden dann auch dargestellt.


Wie das mit der Intersect ist, weiß ich aber nicht.
Hab in der doku dass dazu gefunden.

kann ma das wär erklären oder schnell ein beispiel reintippen?

wär echt super.

mfg




intersects
public boolean intersects(Rectangle r)Determines whether or not this Rectangle and the specified Rectangle intersect. Two rectangles intersect if their intersection is nonempty.

Parameters:
r - the specified Rectangle
Returns:
true if the specified Rectangle and this Rectangle intersect; false otherwise.
 

Wildcard

Top Contributor
Welche Variable denn?
Code:
Rectangle r = new Rectangle(blupp);
Rectangle r2 = new Rectangle(blupp2);
if(r.intersects(r2))
    doSomethingCool();
 

NatroN

Aktives Mitglied
VIELEN DANK

Leider bin ich damit sofort auf etwas gestoßen, was ich befürchtet habe :( :(


Und zwar wird das Rechteck, dass die Kurve fährt ja gedreht...

und genau das wird ja net berücksichtigt... ich habe es schon vorher befürchtet :(

Code:
						 screen2d.rotate(steigung,(int)xWert,(int)yWert);

						 Rectangle SAuto = new Rectangle((int)xWert,(int)yWert,50,20);
						 screen.fillRect(SAuto.x,SAuto.y,SAuto.width,SAuto.height);

						 screen2d.rotate(-steigung,(int)xWert,(int)yWert);
 

Wildcard

Top Contributor
Ja klar, wenn du es drehst geht das natürlich nicht.
Musst du dir wohl eine eigene Rectangle Klasse schreiben und selber rechnen... :wink:
 

NatroN

Aktives Mitglied
naja aber es hilft mir ja trotzdem.

wenn ich mit alle 8 punkte von 2 zu testenden rectangles ausrechne und dann jeweils prüfe, ob einer der 4 endpunkte im anderen rectangle liegt, oder einer der 4 anderen in dem einen rectangle liegt.

Sollte ja mit contains kein Problem sein.

Ein Rectangle Objekt dass man nicht nur gerade, sondern auch gedreht definieren kann (also mit steigung oder so...) wär natrürlich das non plus ultra... aber da es sowas nicht geht (glaube ich) werde ich es mit den Punkten machen müssen...

ist zwar einiges an Tipp aufwand, sollte aber zu machen sein..

noch wer tipps dazu?
 

NatroN

Aktives Mitglied
mist.. geht ja gar nicht...

weil ja auch die Contains Methode nicht richtig arbeitet, wenn der rectangle gedreht ist...

...mist.. jetzt sitz ich wieder am sand..


P.s.: Es interessiert mich auch, ob man ein bereits erzeugtes Rectangle Objekt irgendwie mit neuen Werten bestücken kann... also z.b. die Koordinaten ändern..

mfg
 

NatroN

Aktives Mitglied
Hi Leute...

...leider bin ich jetzt wieder bei 0,.. da die intersects nicht bringt, da das Rectangle gedreht wird.


1) Kann ich irgendwie ein gedrehtes Rectangle Objekt definieren?
2) Wem fällt eine Lösung ein, ob ein Eckpunkt des einen (nicht gedrehten) Rechteckes im anderen (gedrehten) Recheck liegt?

Ich weiß echt nicht wie ich das berechnen soll und die Zeit drängt :(

Bitte helft mir!

mfg
 

Wildcard

Top Contributor
Die einfachste Methode währe IMHO ein eigenes Shape Objekt das sich aus 4-Eckpunkten definiert(also auch ein gedrehtes Rechteck sein kann).
Darin definierst du eine Methode die ein Shape als Paramter erhält, und prüft ob einer der 4
Eckpunkte im diesem Shape liegt. Diese Methode müsstest du dann aber auf beiden beteiligten Shapes aufrufen um eine Überschneidung festzustellen.
 

NatroN

Aktives Mitglied
also am besten ich berechne mir alle eckpunkte.

Dann mache ich das shape objekt (wie am besten) und überprüfe ob einer der 4 Punkte im shape liegt bzw. einer der anderen 4 Punkte im Rectangle.

2 Fragen noch:
1) Wie mach ich das shape objekt wenn ich die eckpunkte hab
2) Wie überprüft man ob ein punkt im Shape liegt oder net?

vielen vielen dank für dene geduld und deine hilfe schon mal!!
 

Wildcard

Top Contributor
1)Was meinst du mit machen?
Das ist ein Objekt das eben 4 Eckpunkte hat!?
Du solltest allerdings im Konstruktor die Ecken 'ordnen', dein Shape sollte also unabhängig von der Eingabe
wissen welcher Punkt links oben ist, welcher links unter,...

2)Die ganz billige 'verschachtelte if's' Methode :wink:
 

NatroN

Aktives Mitglied
hmm...

check weder 1 noch 2 :)

1) wie mach i das mit dem shape objekt?! Ordnen is ja kein Problem, aber das mit dem Objekt is mir ein rätsel? Stückchen code vielleicht? *ganzliebguck* :)


2) hmm.. vielleicht kommts wenn ich mal 1) kapiere, aber daweil weiß ich nicht wie die abfrage aussehen müsste...

mfg
 

Wildcard

Top Contributor
1) was gibts da groß zu sagen? Irgendwas in die Richtung...
Code:
class Shape 
{

    private Point[] points = new Point[4];

    public shape(Point p1, Point p2, Point p3, Point p4)
    {
        //points in Array einsortieren
    }

    public boolean intersects(Shape shape)
    {
       
    }

    public Point[] getPoints()
    {

    }
}

2) Mir fällt da leider auch kein vernünftiger Algorithmus ein. Ich würd es eben mit Geradengleichungen und ein paar if's machen...
 

NatroN

Aktives Mitglied
hallo!

Ok das ist ja jetzt alles soweit klar...

was mich aber interessiert ist eben dieser Algorithmus

ich habe:
Die Steigungen beider Rechtecke und alle 8 Endpunkte kann ich mir berechnen.

Aber wie ich damit auf etwas vernünftiges kommen soll weiß ich nicht, habe mich mit einigen anderen leuten zusammengesetzt, es hat aber keiner eine vernüntige idee.

mfg

edit: Dank nem tipp probier ich grad mit lines rum :)
 
Status
Nicht offen für weitere Antworten.

Oben