Schach(matt) setzen

[Coldstorm]

Ich bin immer noch am implementieren meines Projekts und komme nicht weiter. Es ist ein Schachspiel,
das schon relativ gut funktioniert. Es fehlen noch alle Möglichkeiten der Rochade(4), die Bauernumwandlung und das wichtigste, die Schachbedrohung bzw. Schachmatt anschließend.
En passant ist schon realisiert(nicht von mir).
Wer hat Interesse mir vor allem bei dem Schach setzen auf die Sprünge zu helfen. Michael... und andere haben es ja schon versucht, allerdings bin ich in Java leider ein etwas hoffnungsloser Fall, wenn es zu komplex wird...
Im Anhang findet ihr die lokale Version des Schachs(soll bald Netzwerkschach sein). Einfach den kompletten Ordner ziehen und im Eclipse zum Laufen bringen und funktioniert sofort.
Ich bin um jede Hilfe/Code dankbar. Es ist für mich sehr wichtig, aber das hinzubringen übersteigt meine Fähigkeiten...
Die Main ist übrigens in der Chess.java
Theoretisch auch gegen Zahlung möglich, wenns nicht anders geht...

 

[Marco13]

So ein bestehendes Programm "mal kurz" nachvollziehen, um an einer bestimmten Stelle einen bestimmten Aspekt "einzubauen" kann auch aufwändig sein.

Ganz allgemein: Man muss rausfinden, ob einer den König das anderen schlagen könnte (wenn er dran wäre). Du hast ja schon Methoden zum erstellen aller Züge und so. Du kannst also alle Züge sammeln, und schauen, ob einer der Züge als Zielfeld das Feld eines Königs hat. Und wenn ja, ist's Schach. Um Schachmatt zu erkennen, muss man dann schauen, ob man was gegen die Bedrohung unternehmen kann.

Als GANZ grober Pseudocode:

// Methode um rauszufinden, ob WEISS im Schach steht
// (wird direkt NACH einem Zug von BLACK aufgerufen, um
// die Ansage "Schach" machen zu können)
boolean istWHITEimSchach()
{
    List<Move> allMoves = Alle Züge die BLACK jetzt machen könnte
    for (Move move : allMoves)
    {
        if (move.zielfeld == Feld des WHITE Königs) return true;
    }
    return false;
}

// Methode um rauszufinden, ob WEISS im Schachmatt steht:
boolean istWHITESchachmatt()
{
    List<Move> allMoves = Alle Züge die WHITE jetzt machen könnte
    for (Move move : allMoves)
    {
        führeAus(move);
        boolean istWHITESchach = istWHITEimSchach();
        macheRückgängig(move);
        if (!istWHITESchach)
        {
            // Weiß kann einen Zug machen, nach dem es NICHT mehr
            // im Schah steht -> NICHT Schachmatt
            return false; 
        }
    }
    return true;
}

 

[Coldstorm]

Ja eben GANZ grob, das ist es ja, das bringt mich leider nicht weiter...
Michael... ?? Du bist meine letzte Hilfe

 

[Coldstorm]

Ich habs nun so angefangen, dass ich erstmal prüfe, wie der König bedroht wird, also vertikal, horizontal oder mit dem Springer...aber wie gehts jetzt weiter? PS: Code ist mir immer lieber als eine Beschreibung

	public void checkPositionCanBeBeaten(int x, int y)
	{
	    ArrayList<Point> pointArray = new ArrayList<Point>();

	    // Diagonale und Gerade
	    // Horizontal - Hierbei werden auch gleich die diagonalen gesetzt
	    for(int i=1;i<x;i++)
	    {
	        pointArray.add(new Point(i,y));
	        if(y+(x-i) <= 10)
	            pointArray.add(new Point(i,y+(x-i)));
	        if(y-(x-i) >= 1)
	            pointArray.add(new Point(i,y-(x-i)));
	    }
	    for(int i=x+1;i<=10;i++)
	    {
	        pointArray.add(new Point(i,y));
	        if(y+(i-x) <= 10)
	            pointArray.add(new Point(i,y+(i-x)));
	        if(y-(i-x) >= 1)
	            pointArray.add(new Point(i,y-(i-x)));
	    }
	    // Vertikal
	    for(int i=1;i<y;i++)
	    {
	        pointArray.add(new Point(x,i));
	    }
	    for(int i=y+1;i<=10;i++)
	    {
	        pointArray.add(new Point(x,i));
	    }

	    // Nun der Springer
	    if(x > 0 && y > 1)
	        pointArray.add(new Point(x-1,y-2));
	    if(x < 10 && y > 1)
	        pointArray.add(new Point(x+1,y-2));
	    if(x > 1 && y > 0)
	        pointArray.add(new Point(x-2,y-1));
	    if(x < 9 && y > 0)
	        pointArray.add(new Point(x+2,y-1));
	    if(x > 1 && y < 10)
	        pointArray.add(new Point(x-2,y+1));
	    if(x < 9 && y < 10)
	        pointArray.add(new Point(x+2,y+1));
	    if(x > 0 && y < 9)
	        pointArray.add(new Point(x-1,y+2));
	    if(x < 10 && y < 9)
	        pointArray.add(new Point(x+1,y+2));


	    // dieser Part wäre abgeschlossen
	    // jetzt überprüfen, ob Figuren des anderen Spielers auf den Positionen von pointArray stehen, wie ?
	    // ev kann es hier eine Performanceverbesserung sein, wenn man die Positionen der eigenen Figuren aus dem pointArray löscht, wie ?

	}

 

[Michael...]

Hänge gerade schwer in einem Projekt und hab daher wenig Zeit mir zu solchen komplexen Themen Gedanken zu machen.
Aber prinzipiell kannst Du ja nach jedem Zug prüfen, ob der gegnerische König nun in Schlagdistanz ist. Kannst Dich ja an der Methode collectPossibleTragets() aus BoardModel orientieren.
Einfach für jede (noch aktiv im Spiel verfügbare) eigene Figur die möglichen Zielfelder durch gehen und prüfen, ob sich der gegnerische König darauf befindet, wenn ja --> Schach (evtuell kann man sich noch die Figuren merken, die den König ins Schach stellen)
Im nächsten Schritt die möglichen Zielfelder der gegnerischen Figuren durchgehen (z.B. in einer Liste sammeln) und überprüfen, ob ein Zug auf eines der Zielfelder das Schach beendet (wenn nein wieder aus der Liste rausschmeissen). Ist kein gültiger Zug dabei (die Liste also leer) --> Schach matt

Das ganze ist aber nicht unbedingt trivial.

 

[Coldstorm]

und meinst kann ich das da oben(den Code) irgendwie einbauen/ gebrauchen oder wäre es dann redundant...aber wäre eigentlich egal, Hauptsache es funktioniert

 

[Michael...]

Ich hab nicht verstanden was der Code da oben macht bzw. für was er verwendet werden soll.

 

[Coldstorm]

ja soll halt überprüfen wie ein König Schach gesetzt werden soll, entweder Diagonal, Horizontal/Vertikal oder mit dem Springer...
kennst du eventuell jemanden, der mir weiterhelfen könnte und bisschen Zeit hat übers Wochenende ?

 

[Michael...]

Ich würde da eher von der anderen Seite herangehen und für jede Spielfigur überprüfen, ob sie mit einem Zug das Spielfeld des gegnerischen Königs erreichen kann.
Die Methode collectPossibleTargets() sammelt ja bereits die mit einem Zug erreichbaren Felder einer bestimmten Figur. Ich würde entweder diese erweitern oder kopieren um die Zielfelder aller Figuren zu sammeln und diese Zielfelder mit der Position des Königs zu vergleichen.

Ich kenn nicht so viele Programmierer und die, die ich kenne machen sowas nur gegen Geld und deren Stundensatz möchtest Du vermutlich nicht zahlen ;-)

 

[Coldstorm]

hm...das ist blöd...irgendwie muss ich fertig werden bis nächste Woche...

 

[Coldstorm]

Michael...wie läufts mit deinem Projekt? wann hättest du eventuell Zeit? Am Wochenende vielleicht?
Bist meine einzige Hoffnung...

 

[Michael...]

Danke der Nachfrage, könnte besser laufen ;-)

Ich hab man auf die Schnelle die Klasse BoardModel ein bisschen umgestrickt, dabei wurden die Methoden movePieceTo und collectPossibleTargets etwas umgestrickt.
Das Model habe ich um die Methode checkForCheck (besserer Name ist mir auf die Schnelle nicht eingefallen) ergänzt, die im System.out meldet wenn der gegnerische König in Schach gesetzt wurde (funktioniert nicht unbedingt beim freien Setzen).

Das ganze habe ich jetzt innerhalb von fünf Minuten mal so dahin geschrieben - hätte also sicherlich Verbesserungspotential.

Ausserdem ist der gesamte Code damals ohne grossartige Planung entstanden, da ich eigentlich nie vor hatte ein komplettes Schachprogramm zu schreiben.
Deshalb könnte das Model/Konzept sicherlich noch ein paar Optimierungen/Anpassungen vertragen.

 

[Coldstorm]

Ja genau, danke, das ist das was ich wollte... Kann man da jetzt schon nur mit dem König ziehen oder eine Aktion, die ein Schach verhindert? Das muss ich noch irgendwohin schreiben oder?

 

[Michael...]

Das war ja nur ein Schnellschuss, um zu überprüfen, ob der gegnerische König bedroht ist -als Bsp. wie man herausfindet könnte, ob ein König im Schach steht.
Du musst ja auch noch verhindern, dass ein Spieler sich selbst ins Schach stellt.
Man könnte jetzt nach jedem Zug für beide Könige prüfen, ob Sie bedroht werden. Wird der eigene König bedroht muss der Zug zurück genommen werden.

Schöner wäre es natürlich, wenn man bereits beim Ermitteln der möglichen Züge einer Figur, die Möglichkeiten raus nimmt, mit denen man sich selbst ins Schach stellen würde.