Hi @ all,
habe ein Problem bei der Aufgabenstellung meiner neuen Fachhochschule.
Kurz zum Hintergrund: Bin von der FH Gummersbach zu FH Gelsenkirchen gewechselt.
Mir wurde zwar gesagt das nicht allzu große Unterschiede zwischen allgemeine Informatik (Gummersbach) zu angewandte Informatik Gelsenkirchen) bestehen, aber habe schon ein großes Problem bei den Praktikas.
In der FH Gummersbach haben wir noch nie wirklich mit Swing gearbeitet und somit brauch ich wohl kurz eine Erklärung zu der Aufgabe:
Also wir haben drei vorgegebene Klassen :
Labyrinthdarstellung:
UILabyrinth:
Punkt:
Das soll es erfüllen:
Also wir sollen die Klasse Labyrinth erstellen die bisher so aussieht:
Ich weiß ist noch nicht zufälligs drin etc, aber ich versuch erstmal zu verstehen wie grundlegend abläuft.
So wie meine Klasse jetzt aufgebaut ist zeichnet er ja im Rastermass komplett die Diagonale, so oft wie es das Rastermass in der Breite zulässt (durchläuft die for-Schleife in Labyrinthdarstellung )
Aber das ist ja nicht der Sinn der Sache!
Wie kann ich denn vorher schonmal die Grundform zeichen, eigentlich ja im Konstruktor, aber wie wähle ich die Punkte aus und wie bekomme ich Öffnungen rein? Einfach die Höhe z.B. halbieren und dann da den Endpunkt auswählen?
Und wie zeichne ich danach die zufälligen Labyrinthenwege? Also ich hab überlegt das man ja dann nur mit Math.random ein zufälligen Startpunkt berechnent und dann zu ein zufälligen Endpunkt gehen muss oder habe ich das was falsches im Gedankengang? Also nicht das ihr denkt ich will eine komplette Lösung das soll nicht das Ziel sein, habe nur etwas Startschwierigkeiten in der FH reinzukommen, für Hilfen bin ich euch sehr dankbar. Danke
habe ein Problem bei der Aufgabenstellung meiner neuen Fachhochschule.
Kurz zum Hintergrund: Bin von der FH Gummersbach zu FH Gelsenkirchen gewechselt.
Mir wurde zwar gesagt das nicht allzu große Unterschiede zwischen allgemeine Informatik (Gummersbach) zu angewandte Informatik Gelsenkirchen) bestehen, aber habe schon ein großes Problem bei den Praktikas.
In der FH Gummersbach haben wir noch nie wirklich mit Swing gearbeitet und somit brauch ich wohl kurz eine Erklärung zu der Aufgabe:
Also wir haben drei vorgegebene Klassen :
Labyrinthdarstellung:
Java:
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
/**
* Ein Objekt dieser Klasse stellt ein Labyrinth grafisch dar.
*/
public class Labyrinthdarstellung extends JPanel {
/**
* Innenabstand der Darstellung vom Fensterrand.
*/
private static final int INNENABSTAND = 2;
/**
* Pixel pro Rastereinheit des Labyrinths.
*/
private int rastermass;
/**
* Labyrinth, das dargestellt wird.
*/
private Labyrinth labyrinth;
/**
* Erzeugt ein Objekt dieser Klasse zur Darstellung des
* �bergebenen Labyrinths.
*/
public Labyrinthdarstellung(Labyrinth labyrinth, int rastermass) {
this.labyrinth = labyrinth;
this.rastermass = rastermass;
this.setBorder(new EmptyBorder(INNENABSTAND, INNENABSTAND,
INNENABSTAND, INNENABSTAND));
}
/**
* Liefert bevorzugte Gr��e dieser Darstellung.
*
* @return bevorzugte Gr��e basierend auf Rastermass und
* Gr��e des Labyrinths
*/
@Override
public Dimension getPreferredSize() {
return (labyrinth == null)
? new Dimension(0, 0)
: new Dimension(rastermass * labyrinth.gibBreite()
+ getInsets().left + getInsets().right,
rastermass * labyrinth.gibHoehe()
+ getInsets().top + getInsets().bottom);
}
/**
* Zeichnet das Labyrinth in die angegebene Grafikumgebung.
*
* @param graphics Grafikumgebung, in die gezeichnet wird
*/
public void paintComponent(Graphics graphics) {
super.paintComponent(graphics);
graphics.setColor(Color.BLACK);
for (int i = 0; i < labyrinth.gibAnzahlWandelemente(); i++) {
Punkt startpunkt = labyrinth.gibStartpunkt(i);
Punkt zielpunkt = labyrinth.gibEndpunkt(i);
graphics.drawLine(getInsets().left + rastermass * startpunkt.gibX(),
getInsets().top + rastermass * startpunkt.gibY(),
getInsets().left + rastermass * zielpunkt.gibX(),
getInsets().top + rastermass * zielpunkt.gibY());
}
}
}UILabyrinth:
Java:
import java.awt.Container;
import java.awt.GridLayout;
import javax.swing.JFrame;
/**
* Ein Objekt dieser Klasse dient der Darstellung eines Labyrinths.
*/
public class UILabyrinth extends JFrame {
/**
* H�he des Labyrinths.
*/
private static final int HOEHE = 10;
/**
* Breite des Labyrinths.
*/
private static final int BREITE = 20;
/**
* Pixel pro Rastereinheit des Labyrinths.
*/
private static final int PIXEL_PRO_RASTER = 20;
/**
* Labyrinth, das dargestellt wird.
*/
private Labyrinth labyrinth;
/**
* Komponente zur Darstellung des Labyrinths.
*/
private Labyrinthdarstellung darstellung;
/**
* Erzeugt die Oberfl�che zur Darstellung des �bergebenen Labyrinths.
*
* @param labyrinth Labyrinth, das dargestellt wird
* @param rastermass Anzahl Pixel pro Rastereinheit
*/
public UILabyrinth(Labyrinth labyrinth, int rastermass) {
super("Labyrinth");
this.labyrinth = labyrinth;
/* Erzeugt die Komponenten dieses Frame.
*/
erzeugeKomponenten(labyrinth, rastermass);
/* Anwendung beim Schlie�en dieses Frame beenden.
*/
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
/**
* Erzeugt die Komponenten dieses Frame.
*/
private void erzeugeKomponenten(Labyrinth labyrinth, int rastermass) {
Container container = this.getContentPane();
container.setLayout(new GridLayout(1, 1));
/*
* Objekt zur Darstellung des Labyrinths erzeugen und dem
* Container diesen Frame hinzuf�gen.
*/
darstellung = new Labyrinthdarstellung(labyrinth, rastermass);
container.add(darstellung);
}
/**
* Start der Anwendung.
*
* @param args wird nicht verwendet
*/
public static void main(String[] args) {
UILabyrinth fenster = new UILabyrinth(
new Labyrinth(BREITE, HOEHE), PIXEL_PRO_RASTER);
fenster.pack();
fenster.setResizable(true);
fenster.setVisible(true);
}
}Punkt:
Java:
/**
* Ein Objekt dieser Klasse stellt einen Punkt in einer zweidimensionalen
* Flaeche dar.
*/
public class Punkt {
/**
* Die x-Koordinate dieses Punkts.
*/
private short x;
/**
* Die y-Koordinate dieses Punkts.
*/
private short y;
/**
* Erzeugt einen neuen Punkt.
*
* @param x Die x-Koordinate dieses Punkts.
* @param y Die y-Koordinate dieses Punkts.
*/
public Punkt(int x, int y) {
this.x = (short) x;
this.y = (short) y;
}
/**
* Addiert zwei Punkte koordinatenweise und erzeugt daraus einen neuen Punkt.
*
* @param punkt zu addierender Punkt
* @return neuer Punkt aus den addierten Koordinaten
*/
public Punkt addiere(Punkt punkt) {
return new Punkt(this.x + punkt.x, this.y + punkt.y);
}
/**
* Liefert genau dann true, wenn dieser Punkt sich innerhalb des Rechtecks
* befindet, das durch die beiden �bergebenen Punkte beschrieben wird.
*
* @param linkeObereEcke linke obere Ecke des Rechtecks
* @param rechteUntereEcke rechte untere Ecke des Rechtecks
* @return true genau dann, wenn dieser Punkt im Rechteck liegt
*/
public boolean istInnerhalb(Punkt linkeObereEcke, Punkt rechteUntereEcke) {
return linkeObereEcke.x <= this.x
&& linkeObereEcke.y <= this.y
&& this.x <= rechteUntereEcke.x
&& this.y <= rechteUntereEcke.y;
}
/**
* Gibt die x-Koordinate dieses Punkts zurueck.
*
* @return x-Koordinate
*/
public int gibX() {
return x;
}
/**
* Gibt die y-Koordinate dieses Punkts zurueck.
*
* @return y-Koordinate
*/
public int gibY() {
return y;
}
}Das soll es erfüllen:
Java:
• Das Labyrinth hat eine rechteckige Grundform. Es ist außen von einer Wand umgeben, die an
der linken und der rechten Seite jeweils eine Öffnung besitzt.
• Im Labyrinth gibt es genau einen Weg zwischen den beiden Öffnungen.
• Jede Wand des Labyrinths führt zur Außenwand des Labyrinths.
• Jeder Gang des Labyrinths hat die Breite eines Rasterkästchens.
• Jede Stelle des Labyrinths ist ausgehend von den Öffnungen des Labyrinths erreichbar. Es gibt
also keinen vollständig von einer Wand umschlossenen Bereich.
AbbildungAlso wir sollen die Klasse Labyrinth erstellen die bisher so aussieht:
Java:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author T
*/
class Labyrinth {
private int breite;
private int hoehe;
private Punkt startPunkt = null;
private Punkt endPunkt = null;
Labyrinth(int BREITE, int HOEHE) {
breite = BREITE;
hoehe = HOEHE;
}
int gibBreite() {
return breite;
}
int gibHoehe() {
return hoehe;
}
int gibAnzahlWandelemente() {
return breite;
}
Punkt gibStartpunkt(int i) {
startPunkt = new Punkt (0,i);
System.out.println(i+"Startpunkt :" + startPunkt.gibX() + "|" + startPunkt.gibY());
return startPunkt;
}
Punkt gibEndpunkt(int i) {
endPunkt = new Punkt (breite,i);
System.out.println(i+"Endpunkt: " + endPunkt.gibX() + "|" + endPunkt.gibY());
return endPunkt;
}
}Ich weiß ist noch nicht zufälligs drin etc, aber ich versuch erstmal zu verstehen wie grundlegend abläuft.
So wie meine Klasse jetzt aufgebaut ist zeichnet er ja im Rastermass komplett die Diagonale, so oft wie es das Rastermass in der Breite zulässt (durchläuft die for-Schleife in Labyrinthdarstellung )
Aber das ist ja nicht der Sinn der Sache!
Wie kann ich denn vorher schonmal die Grundform zeichen, eigentlich ja im Konstruktor, aber wie wähle ich die Punkte aus und wie bekomme ich Öffnungen rein? Einfach die Höhe z.B. halbieren und dann da den Endpunkt auswählen?
Und wie zeichne ich danach die zufälligen Labyrinthenwege? Also ich hab überlegt das man ja dann nur mit Math.random ein zufälligen Startpunkt berechnent und dann zu ein zufälligen Endpunkt gehen muss oder habe ich das was falsches im Gedankengang? Also nicht das ihr denkt ich will eine komplette Lösung das soll nicht das Ziel sein, habe nur etwas Startschwierigkeiten in der FH reinzukommen, für Hilfen bin ich euch sehr dankbar. Danke
