echt? Ne ich weis nicht wie die Prüfung zu schreiben bzw formuliert ist
if (aufDasFeldKannGezogenWerden(springer, feld)) {
...
}if (springer.canMoveTo(zielfeld)) { ... }
Chesspiece chesspiece = new Horse(Black, Positioin.B8);
if(chesspiece.getPossiblePositions().equals(someOtherPositoin)){
//...
}chesspiece.getPossiblePositions().equals(someOtherPositoin)Ja dies Möglichkeit hab ichauch schon gesehn aber unser Lehrer will das in der If verzwigung mit Logik gearbeitet wird zB && und ||
Da haste recht...es sollte auch
chesspiece.getPossiblePositions().contains(someOtherPositoin) heißen.
Ich habe eine Möglichkeit die funktioniert aber der Code zur Prüfung ist sehr lang.
Hier hab ich einfach der Reihe nach die möglichen Felder abgearbeitet..
Danke
//Dies sind Enumerationen. Eine Enumeration für Zeilen...
public enum Row{
1 (1),
2 (2),
3 (3),
4 (4),
5 (5),
6 (6),
7 (7),
8 (8);
private final int value;
private Row(int value){
this.value = value;
}
public Row increment(){
int i = value + 1;
if(i > 8){ i = 1;}
return getRowFromValue(i);
}
public Row decrement(){
int i = value - 1;
if(i < 1){ i = 8;}
return getRowFromValue(i);
}
private getRowFromValue(int i){
switch(i){
case 1: return Row.1;
case 2: return Row.2;
case 3: return Row.3;
case 4: return Row.4;
case 5: return Row.5;
case 6: return Row.6;
case 7: return Row.7;
case 8: return Row.8;
}
}
}
//...und eine für Spalten.
public enum Column{
A (1),
B (2),
C (3),
D (4),
E (5),
F (6),
G (7),
H (8);
private final int value;
private Column(int value){
this.value = value;
}
public Column increment(){
int i = value + 1;
if(i > 8){ i = 1;}
return getColumnFromValue(i);
}
public Column decrement(){
int i = value - 1;
if(i < 1){ i = 8;}
return getColumnFromValue(i);
}
private getColumnFromValue(int i){
switch(i){
case 1: return Column.A;
case 2: return Column.B;
case 3: return Column.C;
case 4: return Column.D;
case 5: return Column.E;
case 6: return Column.F;
case 7: return Column.G;
case 8: return Column.H;
}
}
}
//Das ist eine Klasse. Wie eine Klasse benutzt wird...kommt noch. Bis dahin betrachte eine
//Klasse als Bauplan.
public class Position{
private Row row; //Jede Position liegt auf einer Zeile...
private Column column; //...und auf einer Spalte.
public Position(Row row, Column column){ //Dies ist ein Konstruktor.
this.row = row; //Damit wird ein Positionsobjekt erzeugt (kommt auch noch).
this.column = column; //Dem Positionsobjekt muß mit den Übergabeparametern mitgeteilt werden, welche Position es ist.
}
@Override
public int hashCode() {
return Objects.hash(row, column);
}
@Override
public boolean equals(Object obj) { //Diese Methode besorgt einen Vergleich mit anderen Objekten und
if(obj instanceof Position){ //liefert true, wenn das andere Objekt auch ein Positionsobjekt ist UND wenn es diesselben Koordinaten hat.
Position p = (Positon) obj; //Ansonsten false.
return this.row == p.row && this.column == p.column;
}
return false;
}
public void moveToNorth(){
row.increment();
}
public void moveToSouth(){
row.decrement();
}
public void moveToEast(){
column.increment();
}
public void moveToWest(){
column.decrement();
}
public Position clone(){
return new Position(row, column);
}
}
//Dies noch eine Klasse. Besonderheit: diese Klasse ist abstrakt, d.h. es kann kein Objekt
//damit gebaut werden. Warum das so ist - kommt noch. Fürs erste sei gesagt, daß diese
//Klasse für alles zuständig ist was eine Schachfigur ausmacht.
public abstract class ChessPiece{
private Position myPosition;
public ChessPiece(Position startPosition){ //Jede Schachfigur hat eine Position. Die braucht sie schon am Anfang.
myPosition = startPosition;
}
/**
* Liefert die gegenwärtige Position der Schachfigur zurück.
*/
public Position getPosition(){ //Jede Klasse von Typ ChessPiece stellt diese Methode zur Verfügung...
return myPosition;
}
/**
* Stellt die Schachfigur auf eine neue Position.
*/
public void setNewPosition(Position newPosition){ //...genauso wie diese Methode. 'Public' heißt, daß die Methode von überall her öffentlich zugänglich ist.
myPosition = newPosition;
}
protected Position myPosition(){ //Protected heißt, daß die Methode nur von abgeleiteten Klassen (kommt gleich) aufgerufen werden kann.
return myPosition;
}
/**
* Diese Methode liefert ein HashSet mit allen möglichen Positionen,
* auf die das ChessPieceobjekt bewegt werden kann.
*/
public abstract HashSet<Position> getPossiblePositions(); //Dies ist eine abstrakte Methode.
//Was mit dieser leeren Methode gemacht wird - kommt geich.
}
//Dies ist die Klasse für Läufer. Läufer ist von der Art Schachfigur. Was hier gemacht wird, ist als Vererbung bekannt.
//Die Klasse Runner ist eine Art von ChessPiece. Ein Läufer ist eine Schachfigur (aber nicht jede Schachfigur ein Läufer).
//Die Klasse ist nicht mehr abstrakt, da Objekte von ihr gebildet werden sollen. Jetzt ist es vielleicht auch logischer:
//Du kannst nicht einfach eine x-beliebige Schachfigur erzeugen. Woher soll der Compiler wissen, welche du haben willst?
//Eine Figur 'Läufer' ist aber konkret genug, damit der Compiler weiß was du willst.
//Abstrakte Klassen dienen dazu, abstrakte Dinge zu definieren. Konkrete (also nichtabstrakte) Klassen konkretisieren diese.
//Das passiert jetzt mit der Methode getPossiblePositions().
public class Runner extends ChessPiece{
public Runner(Position startPosition){
super(startPosition); //Fordere eine Position ein, auf die die Figur gesetzt werden kann. Mit super() wird der Parameter an die Superklasse durchgereicht.
}
@Override //Die Override-Annotation zeigt an, daß die Methode 'getPossiblePositions' bereits existiert, jedoch überschrieben wird.
public abstract HashSet<Position> getPossiblePositions(){ //Diese Methode wird deshalb in der Superklasse 'ChessPiece' bereits deklariert, weil jede Schachfigur diese Methode haben soll.
HashSet<Position> possiblePositions = new HashSet<>(); //Wir wollen, das jede Schachfigur alle möglichen Positionen, auf die sie von ihrer aktuellen Position aus gesetzt werden kann,
//berechnen kann. Aber was soll 'irgendeine Schachfigur' genau berechnen? Läufer werden nunmal anders gezogen als Bauern, das ist halt so.
//Deshalb wird diese Methode erst hier in der konkreten Klasse implementiert.
Position p = super.myPosition().clone(); //Kopie der aktuellen Position erstellen.
do{ //Die Schleife läuft mindestens einmal.
p.moveToNorth(); //Wir ziehen einmal nach Norden...
p.moveToWest(); //...und einmal nach Westen, sodaß wir auf einem diagonal benachbarten Feld stehen...
possiblePositions.add(p); //...dann kopieren wir diese Position als mögliche Position in das HashSet...
}while(p.equals(super.myPosition()); //...und machen das so lange, bis wir wieder dort stehen wo wir angefangen haben.
//Damit ist eine Diagonale abgefahren.
do{ //Jetzt dasselbe nochmal mit der anderen Diagonalen.
p.moveToSouth();
p.moveToEast();
possiblePositions.add(p);
}whilep.equals(super.myPosition());
return possiblePositions; //Alle möglichen Positionen, auf die der Läufer gesetzt werden kann, sind im HashSet und werden zurückgegeben.
}
}
//Jetzt benutzen wir das Ganze mal:
public static void main(String[] args){
Position runnersStartposition = new Position(Row.1, Column.C); //Die Startposition des Läufers. 'new Position' ruft den Konstruktor der Klasse auf und erzeugt ein Objekt.
Position anotherPosition = new Position(Row.1, Column.F); //Objekte kann man mehrfach erzeugen, man sagt auch instanzieren. runnersStartposition und anotherPosition sind
//Instanzen der Klasse Position.
Runner myRunner = new Runner(runnersStartposition); //Und da ist er, unser erster Läufer.
Runner yourRunner = new Runner(anotherPosition); //Und da ist noch ein zweiter Läufer. Bedenke, daß du für ein richtiges Spiel insgesamt vier Läufer brauchst, die kannst du alle
//genauso instanzieren wie die ersten beiden, mußt aber nur Code für einen einzigen Läufer schreiben. (Auch) deshalb ist Java so geil. :)
//Und hier wird die Ausgangsfrage deines Threads endlich beantwortet:
Position anyPosition;
//...
if(myRunner.getPossiblePositions.contains(anyPosition){
//...
}
}
Die moveTo-Methoden sehen falsch aus, row und column sind ja unveränderlich und den Rückgabewert von increment/decrement ignorierst du aktuell
Das ist halt Englisch for runaways ... So fortgeschrittenes Englisch kann nicht jeder ...
Stimmt, und die Erstellung der Läuferpositionen ist auch noch fehlerhaft. Wenn die Schleife aus dem Spielfeld läuft kommt sie zwar wieder auf der anderen Seite rein, aber nicht dort wo man sie haben will.Die moveTo-Methoden sehen falsch aus, row und column sind ja unveränderlich und den Rückgabewert von increment/decrement ignorierst du aktuell
//Dies sind Enumerationen. Eine Enumeration für Zeilen...
public enum Row{
1 (1),
2 (2),
3 (3),
4 (4),
5 (5),
6 (6),
7 (7),
8 (8);
private final int value;
private Row(int value){
this.value = value;
}
public Row increment(){
int i = value + 1;
if(i > 8){ i = 1;}
return getRowFromValue(i);
}
public Row decrement(){
int i = value - 1;
if(i < 1){ i = 8;}
return getRowFromValue(i);
}
private getRowFromValue(int i){
switch(i){
case 1: return Row.1;
case 2: return Row.2;
case 3: return Row.3;
case 4: return Row.4;
case 5: return Row.5;
case 6: return Row.6;
case 7: return Row.7;
case 8: return Row.8;
}
}
}
//...und eine für Spalten.
public enum Column{
A (1),
B (2),
C (3),
D (4),
E (5),
F (6),
G (7),
H (8);
private final int value;
private Column(int value){
this.value = value;
}
public Column increment(){
int i = value + 1;
if(i > 8){ i = 1;}
return getColumnFromValue(i);
}
public Column decrement(){
int i = value - 1;
if(i < 1){ i = 8;}
return getColumnFromValue(i);
}
private getColumnFromValue(int i){
switch(i){
case 1: return Column.A;
case 2: return Column.B;
case 3: return Column.C;
case 4: return Column.D;
case 5: return Column.E;
case 6: return Column.F;
case 7: return Column.G;
case 8: return Column.H;
}
}
}
//Das ist eine Klasse. Wie eine Klasse benutzt wird...kommt noch. Bis dahin betrachte eine
//Klasse als Bauplan.
public class Position{
private Row row; //Jede Position liegt auf einer Zeile...
private Column column; //...und auf einer Spalte.
public Position(Row row, Column column){ //Dies ist ein Konstruktor.
this.row = row; //Damit wird ein Positionsobjekt erzeugt (kommt auch noch).
this.column = column; //Dem Positionsobjekt muß mit den Übergabeparametern mitgeteilt werden, welche Position es ist.
}
@Override
public int hashCode() {
return Objects.hash(row, column);
}
@Override
public boolean equals(Object obj) { //Diese Methode besorgt einen Vergleich mit anderen Objekten und
if(obj instanceof Position){ //liefert true, wenn das andere Objekt auch ein Positionsobjekt ist UND wenn es diesselben Koordinaten hat.
Position p = (Positon) obj; //Ansonsten false.
return this.row == p.row && this.column == p.column;
}
return false;
}
public void moveToNorth(){
row = row.increment();
}
public void moveToSouth(){
row = row.decrement();
}
public void moveToEast(){
column = column.increment();
}
public void moveToWest(){
column = column.decrement();
}
public Position clone(){
return new Position(row, column);
}
public boolean isBorderPosition(){
return row == Row.1 ||
row == Row.8 ||
column == Column.A ||
column == Column.H;
}
//Dies noch eine Klasse. Besonderheit: diese Klasse ist abstrakt, d.h. es kann kein Objekt
//damit gebaut werden. Warum das so ist - kommt noch. Fürs erste sei gesagt, daß diese
//Klasse für alles zuständig ist was eine Schachfigur ausmacht.
public abstract class ChessPiece{
private Position myPosition;
public ChessPiece(Position startPosition){ //Jede Schachfigur hat eine Position. Die braucht sie schon am Anfang.
myPosition = startPosition;
}
/**
* Liefert die gegenwärtige Position der Schachfigur zurück.
*/
public Position getPosition(){ //Jede Klasse von Typ ChessPiece stellt diese Methode zur Verfügung...
return myPosition;
}
/**
* Stellt die Schachfigur auf eine neue Position.
*/
public void setNewPosition(Position newPosition){ //...genauso wie diese Methode. 'Public' heißt, daß die Methode von überall her öffentlich zugänglich ist.
myPosition = newPosition;
}
protected Position myPosition(){ //Protected heißt, daß die Methode nur von abgeleiteten Klassen (kommt gleich) aufgerufen werden kann.
return myPosition;
}
/**
* Diese Methode liefert ein HashSet mit allen möglichen Positionen,
* auf die das ChessPieceobjekt bewegt werden kann.
*/
public abstract HashSet<Position> getPossiblePositions(); //Dies ist eine abstrakte Methode.
//Was mit dieser leeren Methode gemacht wird - kommt geich.
}
//Dies ist die Klasse für Läufer. Läufer ist von der Art Schachfigur. Was hier gemacht wird, ist als Vererbung bekannt.
//Die Klasse Bishop ist eine Art von ChessPiece. Ein Läufer ist eine Schachfigur (aber nicht jede Schachfigur ein Läufer).
//Die Klasse ist nicht mehr abstrakt, da Objekte von ihr gebildet werden sollen. Jetzt ist es vielleicht auch logischer:
//Du kannst nicht einfach eine x-beliebige Schachfigur erzeugen. Woher soll der Compiler wissen, welche du haben willst?
//Eine Figur 'Läufer' ist aber konkret genug, damit der Compiler weiß was du willst.
//Abstrakte Klassen dienen dazu, abstrakte Dinge zu definieren. Konkrete (also nichtabstrakte) Klassen konkretisieren diese.
//Das passiert jetzt mit der Methode getPossiblePositions().
public class Bishop extends ChessPiece{
public Bishop(Position startPosition){
super(startPosition); //Fordere eine Position ein, auf die die Figur gesetzt werden kann. Mit super() wird der Parameter an die Superklasse durchgereicht.
}
@Override //Die Override-Annotation zeigt an, daß die Methode 'getPossiblePositions' bereits existiert, jedoch überschrieben wird.
public abstract HashSet<Position> getPossiblePositions(){ //Diese Methode wird deshalb in der Superklasse 'ChessPiece' bereits deklariert, weil jede Schachfigur diese Methode haben soll.
HashSet<Position> possiblePositions = new HashSet<>(); //Wir wollen, das jede Schachfigur alle möglichen Positionen, auf die sie von ihrer aktuellen Position aus gesetzt werden kann,
//berechnen kann. Aber was soll 'irgendeine Schachfigur' genau berechnen? Läufer werden nunmal anders gezogen als Bauern, das ist halt so.
//Deshalb wird diese Methode erst hier in der konkreten Klasse implementiert.
Position p = super.myPosition().clone(); //Kopie der aktuellen Position erstellen.
while(p.isBorderPosition){ //Die Schleife läuft solange, bis 'p' die Spielfeldgrenze erreicht.
p.moveToNorth(); //Wir ziehen einmal nach Norden...
p.moveToWest(); //...und einmal nach Westen, sodaß wir auf einem diagonal benachbarten Feld stehen...
possiblePositions.add(p.clone()); //...dann kopieren wir diese Position als mögliche Position in das HashSet.
} //Damit ist die Nord-West-Diagonale abgefahren.
p = myPosition().clone(); //p wieder auf die eigene Positin zurück...
while(p.isBorderPosition){ //...und die Nord-Ost-Diagonale abfahren.
p.moveToNorth();
p.moveToEast();
possiblePositions.add(p.clone());
}
p = myPosition().clone(); //p wieder auf die eigene Positin zurück...
while(p.isBorderPosition){ //...und die Süd-West-Diagonale abfahren.
p.moveToSouth();
p.moveToWest();
possiblePositions.add(p.clone());
}
p = myPosition().clone(); //p wieder auf die eigene Positin zurück...
while(p.isBorderPosition){ //...und die Süd-Ost-Diagonale abfahren.
p.moveToSouth();
p.moveToEast();
possiblePositions.add(p.clone());
}
return possiblePositions; //Alle möglichen Positionen, auf die der Läufer gesetzt werden kann, sind im HashSet und werden zurückgegeben.
}
}
//Jetzt benutzen wir das Ganze mal:
public static void main(String[] args){
Position bishopsStartposition = new Position(Row.1, Column.C); //Die Startposition des Läufers. 'new Position' ruft den Konstruktor der Klasse auf und erzeugt ein Objekt.
Position anotherPosition = new Position(Row.1, Column.F); //Objekte kann man mehrfach erzeugen, man sagt auch instanzieren. bishopsStartposition und anotherPosition sind
//Instanzen der Klasse Position.
Bishop myBishop = new Bishop(bishopsStartposition); //Und da ist er, unser erster Läufer.
Bishop yourBishop = new Bishop(anotherPosition); //Und da ist noch ein zweiter Läufer. Bedenke, daß du für ein richtiges Spiel insgesamt vier Läufer brauchst, die kannst du alle
//genauso instanzieren wie die ersten beiden, mußt aber nur Code für einen einzigen Läufer schreiben. (Auch) deshalb ist Java so geil. :)
//Und hier wird die Ausgangsfrage deines Threads endlich beantwortet:
Position anyPosition;
//...
if(myBishop.getPossiblePositions.contains(anyPosition){
//...
}
}abstract class Chesspiece {
protected final int x, y;
protected Chesspiece(int x, int y) {
this.x = x;
this.y = y;
}
public boolean canMoveTo(int x, int y) {
return x >= 0 && y >= 0 && x < 8 && y < 8;
}
}
class Bishop extends Chesspiece {
public Bishop(int x, int y) {
super(x, y);
}
@Override
public boolean canMoveTo(int x, int y) {
return super.canMoveTo(x, y) && Math.abs(y - this.y) == Math.abs(x - this.x);
}
}Mir gefällt so etwas wie Position(C, 1) im Code recht gut, allein schon weil man allein aufgrund der Werte sieht um was es geht (ok, ich will nicht übertreiben, man sollte schon noch wissen daß der Code zu einem Schachspiel gehört). Klar kannst du mit Integern herummachen, aber was machst du damit besser? Ob x oder y jetzt Zeile oder Spalte sind, sehe ich daraus auch nicht. Überläufe mußt du ebenso abfangen.
Ich würde eher sagen, das kommt darauf an was man später haben will. Die einfache Konvertierung von programmcodeinterner Darstellung nach üblicher Konvention würde ich mir jedenfalls nicht ohne Not verbauen wollen - auch wenn ich dafür zwei relativ übersichtliche Enumklassen schreiben muß, das ist ein akzeptabler Preis. Finde ich jedenfalls.
Ey Leute, hätte ich mal vorher geahnt daß das soviel Resonanz hervorruft hätte ich mir mehr Mühe gegeben.
) benutze ich Enums z.B. um Dateitypen zu unterscheiden. Ein Enum FileType.LIBRARY weist auf eine Datei hin in der eine Bibliothek gespeichert wird, und das Enum liefert auch die zugehörige Dateiendung (in diesem Fall .jCLSlib).Na, aber das tu ich doch. Sieh doch wie 'Position' erzeugt wird. Und ohne ein Positionsobjekt stellst du keine Figur hin. Und das felderweise verrücken wird letztlich ja auch vom Enum besorgt, auch wenn das durch die Positionsklasse verdeckt wird. Inkonsequent war ich bei der Methode isBorderPosition() in der Positionklasse, das hätte auch nochmal an die Enums weiterdelegiert werden müssen.
