Sinnfrage



  • Das Spiel soll viergewinnt sein,
    die class Spielstrategie beinhaltet die Regeln.
    Ich bin nur etwas verwirrt, weil unten in gewonnen die Säulenhoehe ausgerechnet wird, bedeutet das jetzt, dass ob man gewonnen hat immer vom obersten Element aus berechnet wird?
    Oder wird das im Einzelschritt verfahren geprüft ( Weil im Hauptprogramm wird nach jedem Einwurf getestet, ob man gewonnen hat.
    Ich hoffe man kann verstehen auf was ich hinaus will^^.

    lg

    public class SpielStrategie {
    
    	/**
    	 * Ermittelt die Höhe der Säule indem die Anzahl der gesetzten Spielsteine ermittelt wird.
    	 * 
    	 * @param saeule Nummer der Säule
    	 * @return
    	 */
    
    	public static int saeulenHoehe( int saeule ) {
    
    		int hoehe = 0;
    
    		for( int y = 0; y < Spielbrett.brett.length && Spielbrett.brett[y][saeule] != ' '; y++ ) {
    			hoehe++;
    		}
    
    		return hoehe;
    	}
    
    	/**
    	 * Wirt einen Stein in die übergebene Säule ein. Wenn die Säule bereits voll ist wird der Stein nicht
    	 * eingeworfen und die Methode mit "false" beendet
    	 * 
    	 * @param sauele	Nummer der Säule
    	 * @param spieler	Zeichen des Spielers
    	 * @return
    	 */
    
    	public static boolean einwerfen( int sauele, char spieler ) {
    
    		int hoehe = saeulenHoehe( sauele );
    
    		if( hoehe >= Spielbrett.brett.length ) {
    			return false;
    		}
    
    		Spielbrett.brett[hoehe][sauele] = spieler;
    
    		return true;
    	}
    
    	/**
    	 * Zählt wieviele Steine des Spielers aneinander liegen. Beginnend bei der übergebenen Position (x,y)
    	 * wird überprüft ob der aktuelle Spieler gesetzt ist. Falls ja wird der Wert um ein erhöht und das
    	 * nächste Spielfeld wird geprüft
    	 * 
    	 * @param x			Akutelle position
    	 * @param y			Aktuelle position
    	 * @param dx		Schrittweite in x - Richtung
    	 * @param dy		Schrittweite in y - Richtung
    	 * @param spieler	Der zu prüfende Spieler
    	 * @return
    	 */
    
    	public static int zahleSteine( int x, int y, int dx, int dy, char spieler ) {
    
    		if( x < 0 || y < 0 ) {
    			return 0;
    		}
    
    		if( y >= Spielbrett.brett.length ) {
    			return 0;
    		}
    
    		if( x >= Spielbrett.brett[y].length ) {
    			return 0;
    		}
    
    		if( Spielbrett.brett[y][x] != spieler ) {
    			return 0;
    		}
    
    		return 1 + zahleSteine( x + dx, y + dy , dx, dy, spieler );
    	}
    
    	/**
    	 * Ermittelt ob ein Spieler gewonnen hat. Ein spieler hat gewonnen wenn er diagonal, horizontal oder vertikal
    	 * vier aneinander liegende Steie hat
    	 * 
    	 * @param sauele	Nummer der Säule
    	 * @param spieler	Zeichen des Spielers
    	 */
    
    	public static boolean gewonnen( int sauele, char spieler ) {
    
    		int hoehe = saeulenHoehe( sauele ) - 1;
    
    		int horizontal = 	zahleSteine( sauele, hoehe,  1,   0, spieler ) + 
    							zahleSteine( sauele, hoehe, -1,   0, spieler );
    
    		int vertikal   = 	zahleSteine( sauele, hoehe,   0,  1, spieler ) + 
    							zahleSteine( sauele, hoehe,   0,  -1, spieler );
    
    		int diagonala  = 	zahleSteine( sauele, hoehe,   1,  1, spieler ) + 
    							zahleSteine( sauele, hoehe,  -1, -1, spieler );
    
    		int diagonalb  = 	zahleSteine( sauele, hoehe,   1, -1, spieler ) + 
    							zahleSteine( sauele, hoehe,  -1,  1, spieler );
    
    		if( horizontal > 4 || vertikal > 4 || diagonala > 4 || diagonalb > 4 ) {
    			return true;
    		}
    
    		return false;
    	}
    
    }
    


  • hmm ich weiß zwar nicht, was du mit Einzelschritt meinst, aber es wird immer von dem neu gelegten Stein aus ein alle 8 Richtungen gezählt, wieviele Steine von der entsprechenden Person dort liegen. Die Höhe wird für die Position des neuen Steins benötigt.


Log in to reply