GUI "Klick-Tabellen", MouseOver Effekte und 2D-Arr

[Santa]

Moin!

Ich möchte ein kleines Programm mit Java schreiben, das zur Wegfindung mit dem A* Algorithmus dient und habe dazu einige Fragen. Die Forensuche hat leider nur Fehlermeldungen produziert, was in so einem Forum natürlich schlecht ist ... ich bin sicher, die Fragen wurden teilweise schon mehrfach behandelt...
Auf dieser Seite ist ein Applet, das meinen Vorstellungen schon sehr nahe kommt:
http://www.arco.in-berlin.de/astern.html

Als erstes eine Frage zur Programmierung der "Felder":
1. Wie kann ich zweidimensionale Arrays definieren, um dann über Koordinaten auf die Felder zugreifen zu können?
Zum Beispiel soll p[1,3] oder p[1][3] oder wie auch immer das funktioniert dann eben genau das Feld in Zeile 1, Spalte 3 ergeben ...
Eigentlich ne ganz kurze Frage nur, wie halt die Syntax da ist ... und ob ich dann, wenn ich ein array mit je 20 pro dimension, auch wirklich 20*20 = 400 Felder habe ....

2. Wie bekomme ich auf der Oberfläche dieses Kästchenmuster?
Die Felder müssen klickbar sein, optimalerweise so wie im Beispiel, verstiedene Zustände haben, und es müssen auch Bilder in einem Kästchen sichtbar sein können ...

3. Wie mache ich solche MouseOver Effekte (wie im Beispiel), die dann unten links z.B. die Koordinaten, die entsprechenden Werte und den Typ anzeigen?

Mit den Grundlagen von Java kenne ich mich aus, mit der GUI eher weniger, da kenne ich nur Buttons, Testfelder und die einfachen Dinge.
Am Besten wäre natürlich ein Programm, bei dem der SourceCode offen ist, damit ich mir mal angucken kann, wie das gemacht ist

Vielen Dank schon mal für Antworten,


Santa

 

[Wildcard]

1.

int[][] blah = new int[20][20];
blah[0][1]=12;

2. Dafür kannst du einfach JLabels nehmen die du mit einem GridLayout anordnest.

3. Einfach auf jedes Label einen MouseMotionListener adden.

 

[Gast]

mit nem 2d array wirds happig denke ich.
gib dir mal nen kleinen Anstoss...

import java.util.List;

interface Node{

	
	public Node getParent();
	public void setParent(Node n);

	public void initChildren(Node n, int i);
	public List getChildren();

	public int manhattanDistance(Node n);
	public int adjacDist(Node n);
	
	public boolean equals(Node n);
	
	public void setG(int g);
	public void setH(int h);
	
	public int getG();
	public int getH();
	public int getF();
	
}

so ne Node halt...so ein kästchen oder 3D teil...
Und das war ein graues Grid.

import java.util.ArrayList;

public class Grid{
	
	private int size;
	private int height;
	private int width;
	
	private Color color = new Color(200,200,200);
	

	public Grid(int size, int height, int width){
		this.size = size;
		this.height = height;
		this.width = width;		
	}
	
	
	public void draw(Graphics g){
		g.setColor(color);
		
		for(int y = 0; y<= height; y+=size){
				g.drawLine(0, y, height, y);
		}
		for(int x = 0; x<= width; x+=size){
				g.drawLine(x, 0, x, width);
		}
	}
	
	
	public void setGridSize(int s){
		this.size = s;
	}
	
	
	public int getGridSize(){
		return size;
	}
	
	
}

eine sehr gute Page
http://theory.stanford.edu/~amitp/GameProgramming/

und viel erfolg ;-)

 

[Wildcard]

Ein Grid braucht man nicht zeichnen. Das erledigt der LayoutManger durch entsprechende Zwischenräume.

 

[Santa]

1.

int[][] blah = new int[20][20];
blah[0][1]=12;

Danke, mehr wollte ich garnicht wissen! :toll:


Zu den anderen Posts: Danke dafür! :toll:
Aber ich versteh da leider nur wenig ... ???:L

Ich bin bisher immer davon ausgegangen, dass JLabels für Text sind, zum beschriften ... jetzt sollen sie das Layout darstellen? Klickbar? Bunt? Mit Bildchen?
Und was fürn GridLayout? Gibts da schon was vorgegebenes?
Und was ist "Node"? Dein Denkanstoss - was ist das? Sieht nach den Kopfzeilen von Funktionen aus irgendwie ...
G, H, F, sind das die gefahrene Distanz, die noch erwartete, und die Summe?
Was für children? Kinder sollen die nicht haben :lol:
Und soll ich dann ein 2D-Array mit Nodes machen?
Was ist interface? Ich kenne nur class am Anfang ...
Und was für ein LayoutManager?

Ich kann ja mal sagen, wie ich mir das gedacht hatte, ohne vorher groß was über die Implementierung des A* gelesen zu haben (man will ja was lernen, und sich erstmal selbst Gedanken machen):
Ich habe ein Array aus meinetwegen 10*10 Kästchen. Diese Kästchen-Klasse hat auch Eigenschaften, wie die Richtung (NO, O, SO, SW, ...) aus der sie gekommen ist, der gegangene Weg, der erwartete Restweg, und die Summe daraus.
Irgendeine Prozedur arbeitet dann nacheinander die Kästchen daneben ab (so nach dem Motto kästchen[aktuell-1][aktuell-1].berechnen() für das SüdOst-Kästchen), entscheidet sich für eins, und fängt dann von vorn an ...

 

[Gast]

Deine Überlegung ist gut so.

Der Gedanke der Node ist so.

Eine Node ist ein Punkt im Koordinatensystem (2d oder 3d).

Jede Node hat einen Vater. also der Vorgänger des Weges. (setParent)
Der erste Knoten hat Kinder (4 oder 8) (N,O,S,W) oder (N,NO,..)

Jeder Knoten hat einen Weg den er gemacht hat setG und einen Weg zum Ziel der Geschätzt wird setH (Heuristik).
Daraus ergibt sich der gesamte Weg getF().

Nun werden alle Kinder abgeschätzt und geschaut welches der Kinder ist der beste (schnellster Weg). Dieses Kind wird genommen und der Vater setParent gesetzt. Dies geht dann so weiter bis das Ziel erreicht wird oder ein Hindernis kommt.

Der beste Weg ist der letzte Knoten (der beste) und alle getParent bis zum Start rekursiv.

ändert sich auf dem Weg (es gibt ein besser Weg auf einer anderen Strecke), so wird jeweil rekursiv die setParents bis nach oben wo nötig geändert.

Vielleicht ist es so ein wenig verstänlicher ;-)

 

[Santa]

Deine Überlegung ist gut so.

Der Gedanke der Node ist so.

Eine Node ist ein Punkt im Koordinatensystem (2d oder 3d).

Jede Node hat einen Vater. also der Vorgänger des Weges. (setParent)
Der erste Knoten hat Kinder (4 oder 8) (N,O,S,W) oder (N,NO,..)

Jeder Knoten hat einen Weg den er gemacht hat setG und einen Weg zum Ziel der Geschätzt wird setH (Heuristik).
Daraus ergibt sich der gesamte Weg getF().

Nun werden alle Kinder abgeschätzt und geschaut welches der Kinder ist der beste (schnellster Weg). Dieses Kind wird genommen und der Vater setParent gesetzt. Dies geht dann so weiter bis das Ziel erreicht wird oder ein Hindernis kommt.

Der beste Weg ist der letzte Knoten (der beste) und alle getParent bis zum Start rekursiv.

ändert sich auf dem Weg (es gibt ein besser Weg auf einer anderen Strecke), so wird jeweil rekursiv die setParents bis nach oben wo nötig geändert.

Vielleicht ist es so ein wenig verstänlicher ;-)

Ja, das sieht gut aus. So hatte ich mir das auch ungefähr vorgestellt.
Das heißt, ich mache ein Node-Array, und verknüpfe dann die Nodes miteinander über setParent und die Kinder?
Damit ist das System schonmal klar ...

Jetzt ist die Frage, wie ich sowas grafisch darstellen kann ... da bin ich schon tagelang am Überlegen. Ich wollte erst ganz viele Buttons machen, aber das scheint mir irgendwie zu kompliziert...

 

[Gast]

Die Kinder sind die Nachbarn. Je nach dem wie das System aufgebaut wird machst du evtl eine List die alle Knoten beinhalten, die schon mal gebraucht wurden. Somit gibt es jedes Node Objekt nur einmal. Je nach Wunsch. So kann immer wieder aus dem Topf die Knoten geholt werden die schon da sind und evtl ein update gemacht werden und neue werden neu gemacht.
Bei grossen Systemen evtl von nachteil. Aber Allgemien lieber RAM brauchen als CPU um neue Obkjekte zu erstellen.

Wie zeichnen must du dir überlegen. zB via paint-Methode bei awt oder paintComponent bei swing. Oder gant einen anderen Ansatz ist da auch denkbar, wenn über Swing Obkjekte gearbeitet wird.

Wenn eine Node(x,y) als Koordinaten hat und ein Grid zB 10*10 Pixel ist zB (x,y, x+10,y+10) bemalen (=schon besucht).

Viele Buttons...hmmm? für was?

 

[Santa]

Die Kinder sind die Nachbarn. Je nach dem wie das System aufgebaut wird machst du evtl eine List die alle Knoten beinhalten, die schon mal gebraucht wurden. Somit gibt es jedes Node Objekt nur einmal. Je nach Wunsch. So kann immer wieder aus dem Topf die Knoten geholt werden die schon da sind und evtl ein update gemacht werden und neue werden neu gemacht.
Bei grossen Systemen evtl von nachteil. Aber Allgemien lieber RAM brauchen als CPU um neue Obkjekte zu erstellen.

Wie zeichnen must du dir überlegen. zB via paint-Methode bei awt oder paintComponent bei swing. Oder gant einen anderen Ansatz ist da auch denkbar, wenn über Swing Obkjekte gearbeitet wird.

Wenn eine Node(x,y) als Koordinaten hat und ein Grid zB 10*10 Pixel ist zB (x,y, x+10,y+10) bemalen (=schon besucht).

Viele Buttons...hmmm? für was?

Erstmal zum zweiten Teil ... die GUI.
Das Problem mit dem einfachen Malen ist, dass ich die Mauern etc. ja alle gerne selber setzen möchte, so wie im Beispiel oben. Das heißt, ich kann jedes Feld anklicken, und es wird in eine Mauer umgewandelt. Auch Start und Ziel sollen gesetzt werden. Und danach will ich dann in die ganzen leeren Felder die Pfeile der Richtungsangaben eintragen ...
Das ist mit einfachem Paint nicht so leicht möglich, oder!?

Zu den Kindern, den Nachbarn und den Knoten: Das habe ich nicht ganz verstanden. Ich wollte die Knoten eigentlich alle gleich am Anfang definieren, wie gesagt als Array .... irgendwie sowas:

knoten[][] k = new knoten[10][10];
k[1][1].getBest();

(getBest als Methode, die ermittelt, welches das nächste Feld ist)
Wenn ich die Knoten einfach so definiere, einen als Startknoten, einen als Zielknoten, alle mit ihren Nachbarn ... dann ist die Frage, wie ich noch einfach den Weg berechnen soll, der erwartet wird. Ich weiß ja schließlich nicht, wo ich den Zielknoten erwarten soll. Bei Arrays könnte ich einfach die x und y Koordinaten vergleichen, die Differenz nehmen und fertig :?: :!:
Und außerdem: Das wird dann ne ganz schöne Arbeit, am Anfang alle Knoten zu definieren! Wenn ich das Muster abhängig von dem, was auf der GUI eingetragen wurde, eingeben soll ... dann muss ich ja vom Start ausgehend in alle Richtungen mühsam die Nachbarn machen, oder?
Das stelle ich mir mit Arrays einfacher vor: Ich gucke in der GUI bei der Position 1|1, stelle Fest dass es eine Wand ist, erstelle einen neuen Knoten k[1][1] mit irgendeinem Wert, der verdeutlicht, dass es ne Wand ist (boolean wand = true oder sowas), und dann immer so weiter, einfach als zwei for-Schleifen ineinander.

Bleiben also die zwei Fragen:
1) Knoten als Array, oder ohne?
2) Wie geht die GUI?

 

[Guest]

http://theory.stanford.edu/~amitp/GameProgramming/

für die Berechnung.

einfach und schnell gemacht --> Manhattan Distance

wie du den aStar implementierst ist die überlassen.
eigentlich ist es ja nur ein DSSP (Dijkstras Single Shortest Path) mit einer Schätzkomponente (Heuristik).

Das interface definiert nur die Struktur einer Node nicht die Node selber.

Denkbar für 2d zb

public class Node2d extends Node{

	private int x;
	private int y;

	public Node2d(int x, int y){
		this.x = x;
		this.y = y;
	}

	public int manhattanDistance(Node t){
		Node2D node =  (Node2D)t;
		
		return (Math.abs( (node.x - this.x)) + 
				Math.abs( (node.y - this.y)));
	}

	//und alle getter und setter hier

	//und alles was du noch brauchst
	//wie Distance,Schätzung, TOT
}

Knoten in Array oder nicht. Dir überlassen. Ich arbeiter gerne zB mit List
Hier wäre vielleicht ein Set sehr gut, da es keine doppelten einträge gibt.

Die Knoten werden on the fly gemacht. Der Strart Knoten holt seine Nachbarn.
Evaluiert alle, und weiter mit dem besten von allen. usw mit dem besten.
--> Algo-Details.....

für die Berechnungen..mach ein einfaches Beispiel. zb 3*3 Matrix
in der Mitte hats ein Obstacle oder nicht. Weg diagonale oder nicht.

Die Wände/Sümpfe/Wälder können auch Node sein, aber nicht begehbare.

zum eigenlichen aStar (wird meist mit 2 Collection implementiert)

http://de.wikipedia.org/wiki/A*-Algorithmus
http://www.policyalmanac.org/games/aStarTutorial_de.html >> gut


2. GUI

das musst du die überlegen.
wie gesagt mit paint zb ...alles musst du selber definieren..

greets

 

[Wildcard]

Ich bin bisher immer davon ausgegangen, dass JLabels für Text sind, zum beschriften ... jetzt sollen sie das Layout darstellen? Klickbar? Bunt? Mit Bildchen?
Und was fürn GridLayout? Gibts da schon was vorgegebenes?
...

In GUIs musst du dich selbst einlesen. das kann dir keiner abnehmen.
Alles was du brauchst ist ein JPanel mit GridLayout auf das du JLabels (ausgestattet mit MouseListener und evtl MouseMotionListener) setzt.
Den Labels setzt du dann einfach Farben oder ImageIcons.
Selbst zeichnen brauchst du eigentlich gar nichts.

 

[Guest]

1.

int[][] blah = new int[20][20];
blah[0][1]=12;

Danke, mehr wollte ich garnicht wissen! :toll:


Zu den anderen Posts: Danke dafür! :toll:
Aber ich versteh da leider nur wenig ... ???:L

Ich bin bisher immer davon ausgegangen, dass JLabels für Text sind, zum beschriften ... jetzt sollen sie das Layout darstellen? Klickbar? Bunt? Mit Bildchen?
Und was fürn GridLayout? Gibts da schon was vorgegebenes?
Und was ist "Node"? Dein Denkanstoss - was ist das? Sieht nach den Kopfzeilen von Funktionen aus irgendwie ...
G, H, F, sind das die gefahrene Distanz, die noch erwartete, und die Summe?
Was für children? Kinder sollen die nicht haben :lol:
Und soll ich dann ein 2D-Array mit Nodes machen?
Was ist interface? Ich kenne nur class am Anfang ...
Und was für ein LayoutManager?

Ich kann ja mal sagen, wie ich mir das gedacht hatte, ohne vorher groß was über die Implementierung des A* gelesen zu haben (man will ja was lernen, und sich erstmal selbst Gedanken machen):
Ich habe ein Array aus meinetwegen 10*10 Kästchen. Diese Kästchen-Klasse hat auch Eigenschaften, wie die Richtung (NO, O, SO, SW, ...) aus der sie gekommen ist, der gegangene Weg, der erwartete Restweg, und die Summe daraus.
Irgendeine Prozedur arbeitet dann nacheinander die Kästchen daneben ab (so nach dem Motto kästchen[aktuell-1][aktuell-1].berechnen() für das SüdOst-Kästchen), entscheidet sich für eins, und fängt dann von vorn an ...