API tools faq
paste
Advertisement
Guest User

CSchach.java

a guest
Jan 27th, 2011
287
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 25.03 KB | None | 0 0
raw download clone embed print report
  1. /*Dies ist Schach Version 1.5
  2.  
  3.  * Coded by Crushpest & Jocker
  4.  
  5.  *
  6.  
  7.  * Man sollte vielleicht auch ein paar regeln erstellen, damit es egal wird, ob man groß oder klein schreibt!
  8.  
  9.  * Vielleicht auch  noch hinzufuegen, das es egal ist, ob man den figurnamen oder das feld angibt, die man ziehen will
  10.  
  11.  * Zudem Fehlen noch regeln:
  12.  
  13.  * -Rochade
  14.  
  15.  *
  16.  
  17.  * Also hab das Problem mit der Darstellung geloest. Werde vielleicht noch die feldfarben einfuegen wie du es gemacht hast
  18.  
  19.  *
  20.  
  21.  * Fehler die Bisher beim Spielen aufgetretten sind:
  22.  
  23.  * -Dame kann nicht wie ein Laeufer ziehen
  24.  
  25.  * -Bauer kann nicht schlagen, wenn ein eigener bauer auf einer der beiden schlagfelder steht
  26.  
  27.  */
  28.  
  29.  
  30.  
  31. import java.util.Scanner;
  32.  
  33.  
  34.  
  35. public class CSchach {
  36.  
  37.     //Define Variables
  38.  
  39.     public static Scanner eingabe = new Scanner(System.in);
  40.  
  41.     public static String spielerWeiß;
  42.  
  43.     public static String spielerSchwarz;
  44.  
  45.     public static String[] figuren = {"Turm1", "Springer1", "Laeufer1", "Dame", "Koenig", "Laeufer2", "Springer2", "Turm2", "Bauer"};
  46.  
  47.     public static String[] buchstaben = {"A", "B", "C", "D", "E", "F", "G", "H"};
  48.  
  49.     public static String[] zahlen = {"1", "2", "3", "4", "5", "6", "7", "8"};
  50.  
  51.     public static String[][] brett = new String[8][8];
  52.  
  53.     public static boolean schachMatt;
  54.  
  55.     public static int runde;
  56.  
  57.     public static int anzahlDamen = 1;
  58.  
  59.  
  60.  
  61.     //Spiel-Menu
  62.  
  63.     public static void main(String[] arg){
  64.  
  65.         //Wilkommensbildschirm
  66.  
  67.         println("Hallo und herzlich Wilkommen zu Schach.");
  68.  
  69.         println("Dieses Spiel wurde von Crushpest und Jocker geschrieben und ist Open Source.");
  70.  
  71.         println("");
  72.  
  73.        
  74.  
  75.         //Starte Menu
  76.  
  77.         boolean beenden = false;
  78.  
  79.        
  80.  
  81.         do{
  82.  
  83.             println("");
  84.  
  85.             println("1  Spiel starten");
  86.  
  87.             println("2  Spiel beenden");
  88.  
  89.             print("Bitte wählen: ");
  90.  
  91.             int wahl = eingabe.nextInt();
  92.  
  93.            
  94.  
  95.             switch(wahl){
  96.  
  97.                 case 1:
  98.  
  99.                     starteSpiel();
  100.  
  101.                     break;
  102.  
  103.                 case 2:
  104.  
  105.                     beenden = true;
  106.  
  107.                     break;
  108.  
  109.                 default:
  110.  
  111.                     println("Eingabe war falsch!");
  112.  
  113.                     break;
  114.  
  115.             }//end switch
  116.  
  117.         }while(!beenden);
  118.  
  119.        
  120.  
  121.         //Am Ende ausgeben
  122.  
  123.         println("Danke und bis bald!");
  124.  
  125.     }
  126.  
  127.  
  128.  
  129.     //Hauptteil des Spiels
  130.  
  131.     public static void starteSpiel(){
  132.  
  133.         //SpielBrett vorbereiten
  134.  
  135.         initBrett();
  136.  
  137.         spielerNamen();
  138.  
  139.        
  140.  
  141.         //Zeige SpielInfos
  142.  
  143.         zeigeSpielInfos();
  144.  
  145.        
  146.  
  147.         //Beginne das Spiel
  148.  
  149.         if(spielSchleife()){
  150.  
  151.             println("Schachmatt!!!");
  152.  
  153.             println("Weiß hat gewonnen!!!");
  154.  
  155.             println(spielerWeiß+" hat "+spielerSchwarz+" in "+runde+" Schachmatt gesetzt!");
  156.  
  157.         }else{
  158.  
  159.             println("Schachmatt!!!");
  160.  
  161.             println("Schwarz hat gewonnen!!!");
  162.  
  163.             println(spielerSchwarz+" hat "+spielerWeiß+" in "+runde+" Runden Schachmatt gesetzt!");
  164.  
  165.         }//end if
  166.  
  167.         println("");
  168.  
  169.     }
  170.  
  171.    
  172.  
  173.     //Hier ist die Spielschleife
  174.  
  175.     public static boolean spielSchleife(){
  176.  
  177.         runde = 1;
  178.  
  179.         schachMatt = false;
  180.  
  181.         boolean weißAmZug = true;
  182.  
  183.        
  184.  
  185.         //Beginne Spiel Schleife
  186.  
  187.         while(true){
  188.  
  189.             String wahl;
  190.  
  191.            
  192.  
  193.             zeigeSpielbrett(weißAmZug);
  194.  
  195.            
  196.  
  197.             if(weißAmZug){
  198.  
  199.                 println(spielerWeiß+", du bist dran!");
  200.  
  201.                 print("Ziehen: ");
  202.  
  203.                 wahl = eingabe.next();
  204.  
  205.                 wahl = wahl+" "+eingabe.next();
  206.  
  207.                 //Prüfe zug
  208.  
  209.                 boolean zugErfolgreich = zugKontrolle(wahl, weißAmZug);
  210.  
  211.                 while(!zugErfolgreich){
  212.  
  213.                     println("Bitte nochmal ziehen!");
  214.  
  215.                     print("Ziehen: ");
  216.  
  217.                     wahl = eingabe.next();
  218.  
  219.                     wahl = wahl+" "+eingabe.next();
  220.  
  221.                     zugErfolgreich = zugKontrolle(wahl, weißAmZug);
  222.  
  223.                 }
  224.  
  225.                 if(schachMatt) return true;
  226.  
  227.                 weißAmZug = false;
  228.  
  229.             }else{
  230.  
  231.                 println(spielerSchwarz+", du bist dran!");
  232.  
  233.                 print("Ziehen: ");
  234.  
  235.                 wahl = eingabe.next();
  236.  
  237.                 wahl = wahl+" "+eingabe.next();
  238.  
  239.                 //Prüfe zug
  240.  
  241.                 boolean zugErfolgreich = zugKontrolle(wahl, weißAmZug);
  242.  
  243.                 while(!zugErfolgreich){
  244.  
  245.                     println("Bitte nochmal ziehen!");
  246.  
  247.                     print("Ziehen: ");
  248.  
  249.                     wahl = eingabe.next();
  250.  
  251.                     wahl = wahl+" "+eingabe.next();
  252.  
  253.                     zugErfolgreich = zugKontrolle(wahl, weißAmZug);
  254.  
  255.                 }
  256.  
  257.                 if(schachMatt) return false;
  258.  
  259.                 weißAmZug = true;
  260.  
  261.             }//end if
  262.  
  263.             runde++;
  264.  
  265.         }//end while
  266.  
  267.     }
  268.  
  269.    
  270.  
  271.     //Start des Spiels vorbereiten
  272.  
  273.     public static void initBrett(){
  274.  
  275.         //Brett fuellen
  276.  
  277.         for(int zeile = 0; zeile < 8; zeile++){
  278.  
  279.             for(int spalte = 0; spalte < 8; spalte++){
  280.  
  281.                 brett[zeile][spalte] = "";
  282.  
  283.             }//end for
  284.  
  285.         }//end for
  286.  
  287.        
  288.  
  289.         //Mit Figuren Weiß fuellen
  290.  
  291.         int zahl = 0;
  292.  
  293.         int figur = 0;
  294.  
  295.         for(int zeile = 0; zeile < 2; zeile++){
  296.  
  297.             for(int spalte = 0; spalte < 8; spalte++){
  298.  
  299.                 if(zeile == 0){
  300.  
  301.                     brett[zeile][spalte] = "W "+figuren[figur];
  302.  
  303.                     figur++;
  304.  
  305.                 }else{
  306.  
  307.                     brett[zeile][spalte] = "W "+figuren[8]+zahlen[zahl];
  308.  
  309.                     zahl++;
  310.  
  311.                 }//end if
  312.  
  313.             }//end for
  314.  
  315.         }//end for
  316.  
  317.        
  318.  
  319.         //Mit Figuren Schwarz fuellen
  320.  
  321.         zahl = 0;
  322.  
  323.         figur = 0;
  324.  
  325.         for(int zeile = 7; zeile >= 6; zeile--){
  326.  
  327.             for(int spalte = 7; spalte >= 0; spalte--){
  328.  
  329.                 if(zeile == 7){
  330.  
  331.                     brett[zeile][spalte] = "S "+figuren[figur];
  332.  
  333.                     figur++;
  334.  
  335.                 }else{
  336.  
  337.                     brett[zeile][spalte] = "S "+figuren[8]+zahlen[zahl];
  338.  
  339.                     zahl++;
  340.  
  341.                 }//end if
  342.  
  343.             }//end for
  344.  
  345.         }//end for
  346.  
  347.     }
  348.  
  349.    
  350.  
  351.     //Anleitung zum Spiel anzeigen
  352.  
  353.     public static void zeigeSpielInfos(){
  354.  
  355.         //Gebe Spielinfos aus
  356.  
  357.         println("S und W vor den Figurnamen steht fuer Schwarz und Weiß");
  358.  
  359.         println("Bsp.: Weiß ist am Zug und moechte den Bauern5 ein Feld nach vorne ziehen.");
  360.  
  361.         println("Eingabe: Bauer5 E4");
  362.  
  363.         println("oder: E2 E4");
  364.  
  365.         println("");
  366.  
  367.         println("Groß und Kleinschreibung ist egal!");
  368.  
  369.         println("S und W muessen nicht vor den Figurennamen geschrieben werden!");
  370.  
  371.         println("");
  372.  
  373.         println("Bleibt nur noch eins:");
  374.  
  375.         println("Weiß Beginnt, Schwarz Gewinnt ;)");
  376.  
  377.         println("");
  378.  
  379.     }
  380.  
  381.    
  382.  
  383.     //SpielerNamen festlegen
  384.  
  385.     public static void spielerNamen(){
  386.  
  387.         do{
  388.  
  389.             //Frage und speichere Spielernamen ab
  390.  
  391.             print("Bitte Name fuer Spieler Weiß eingeben: ");
  392.  
  393.             spielerWeiß = eingabe.next();
  394.  
  395.        
  396.  
  397.             print("Bitte Name fuer Spieler Schwart eingeben: ");
  398.  
  399.             spielerSchwarz = eingabe.next();
  400.  
  401.         }while(spielerWeiß.isEmpty() || spielerSchwarz.isEmpty());
  402.  
  403.     }
  404.  
  405.    
  406.  
  407.     //Hauptteil zur Kontrolle des Zugs
  408.  
  409.     public static boolean zugKontrolle(String wahl, boolean weiß){
  410.  
  411.         //Define Variables
  412.  
  413.         char prefix;
  414.  
  415.         String[] zug = wahl.split(" ");
  416.  
  417.         String altBuchstabe, altZahl, neuBuchstabe, neuZahl, figur;
  418.  
  419.         int[] altePosition = new int[2];
  420.  
  421.         int[] neuePosition = new int[2];
  422.  
  423.        
  424.  
  425.         //Bestimme Prefix
  426.  
  427.         if(weiß){
  428.  
  429.             prefix = 'W';
  430.  
  431.         }else{
  432.  
  433.             prefix = 'S';
  434.  
  435.         }//end if
  436.  
  437.        
  438.  
  439.         //Bestimmme ob altes Feld figur oder Feld ist
  440.  
  441.         if(zug[0].length() == 2){
  442.  
  443.             altBuchstabe = zug[0].substring(0, 1);
  444.  
  445.             altZahl = zug[0].substring(1);
  446.  
  447.             String[] altesFeld = {altBuchstabe, altZahl};
  448.  
  449.             if(contains(buchstaben, altBuchstabe) && contains(zahlen, altZahl)){
  450.  
  451.                 altePosition = bestimmePosition(altesFeld, weiß);
  452.  
  453.                 figur = brett[altePosition[0]][altePosition[1]];
  454.  
  455.             }else{
  456.  
  457.                 println("Eingabe war falsch!");
  458.  
  459.                 return false;
  460.  
  461.             }//end if
  462.  
  463.         }else{
  464.  
  465.             figur = zug[0];
  466.  
  467.             if(figur.contains("Bauer") || figur.contains("bauer")){
  468.  
  469.                 altePosition = bestimmePosition(prefix+" "+figur);
  470.  
  471.             }else if(contains(figuren, figur)){
  472.  
  473.                 altePosition = bestimmePosition(prefix+" "+figur);
  474.  
  475.             }else{
  476.  
  477.                 println("Eingabe war falsch");
  478.  
  479.                 return false;
  480.  
  481.             }//end if
  482.  
  483.         }//end if
  484.  
  485.         //Bestimme neues feld
  486.  
  487.         neuBuchstabe = zug[1].substring(0, 1);
  488.  
  489.         neuZahl = zug[1].substring(1);
  490.  
  491.         String[] neuesFeld = {neuBuchstabe, neuZahl};
  492.  
  493.         if(contains(buchstaben, neuBuchstabe) && contains(zahlen, neuZahl)){
  494.  
  495.             neuePosition = bestimmePosition(neuesFeld, weiß);
  496.  
  497.         }else{
  498.  
  499.             println("Eignabe war falsch");
  500.  
  501.             return false;
  502.  
  503.         }//end if
  504.  
  505.        
  506.  
  507.         //Pruefe auf gueltigkeit des Zugs, wenn nein return false
  508.  
  509.         if(!zugLegal(altePosition, neuePosition, figur, weiß)){
  510.  
  511.             println("Diese Figur kann nicht so ziehen!");
  512.  
  513.             return false;
  514.  
  515.         }//end if
  516.  
  517.        
  518.  
  519.         //Pruefe ob geschlagen werden kann
  520.  
  521.         if(!feldLeer(neuePosition)){
  522.  
  523.             if(!schlagen(neuePosition, weiß)){
  524.  
  525.                 println("Diese Figur kann nicht geschlagen werden!");
  526.  
  527.                 return false;
  528.  
  529.             }//end if
  530.  
  531.             println(brett[altePosition[0]][altePosition[1]]+" schlaegt "+brett[neuePosition[0]][neuePosition[1]]);
  532.  
  533.         }//end if
  534.  
  535.        
  536.  
  537.         //Pruefe auf BauerDameTausch
  538.  
  539.         boolean neueDame = bauerDameTausch(neuePosition, weiß);
  540.  
  541.        
  542.  
  543.         //Ziehe Figur auf neue Position
  544.  
  545.         ziehen(altePosition, neuePosition, neueDame, prefix);
  546.  
  547.        
  548.  
  549.         //Zug war erfolgreich
  550.  
  551.         return true;
  552.  
  553.     }
  554.  
  555.    
  556.  
  557.     //Bestimme Position der Figur
  558.  
  559.     public static int[] bestimmePosition(String figur){
  560.  
  561.         int[] ergebnis = new int[2];
  562.  
  563.        
  564.  
  565.         for(int zeile = 0; zeile < 8; zeile++){
  566.  
  567.             for(int spalte = 0; spalte < 8; spalte++){
  568.  
  569.                 if(brett[zeile][spalte].equalsIgnoreCase(figur)){
  570.  
  571.                     ergebnis[0] = zeile;
  572.  
  573.                     ergebnis[1] = spalte;
  574.  
  575.                     return ergebnis;
  576.  
  577.                 }//end if
  578.  
  579.             }//end for
  580.  
  581.         }//end for
  582.  
  583.         return null;
  584.  
  585.     }
  586.  
  587.    
  588.  
  589.     //Bestimme Position der Koordinate
  590.  
  591.     public static int[] bestimmePosition(String[] feld, boolean weiß){
  592.  
  593.         int[] ergebnis = new int[2];
  594.  
  595.    
  596.  
  597.         for(int count = 0; count < 8; count++){
  598.  
  599.             if(buchstaben[count].equalsIgnoreCase(feld[0])){
  600.  
  601.                 ergebnis[1] = count;
  602.  
  603.             }//end if
  604.  
  605.             if(zahlen[count].equalsIgnoreCase(feld[1])){
  606.  
  607.                 ergebnis[0] = count;
  608.  
  609.             }//end if
  610.  
  611.         }//end for
  612.  
  613.        
  614.  
  615.         //Wenn Schwarz, dann muss es von hinten gezaehlt werden
  616.  
  617.         if(!weiß){
  618.  
  619.             int zeile = 7 - ergebnis[0];
  620.  
  621.             int spalte = 7 - ergebnis[1];
  622.  
  623.            
  624.  
  625.             ergebnis[0] = zeile;
  626.  
  627.             ergebnis[1] = spalte;
  628.  
  629.         }//end if
  630.  
  631.         return ergebnis;
  632.  
  633.     }
  634.  
  635.    
  636.  
  637.     //Pruefe ob feld leer ist
  638.  
  639.     public static boolean feldLeer(int[] feld){
  640.  
  641.         if(!brett[feld[0]][feld[1]].isEmpty()){
  642.  
  643.             return false;
  644.  
  645.         }//end if
  646.  
  647.         return true;
  648.  
  649.     }
  650.  
  651.    
  652.  
  653.     //Bestimmt ob die Figur diesen zug machen darf
  654.  
  655.     public static boolean zugLegal(int[] alt, int[] neu, String figur, boolean weiß){
  656.  
  657.         //Define Variable
  658.  
  659.         int neuezeile = neu[0];
  660.  
  661.         int neuespalte = neu[1];
  662.  
  663.         int altezeile = alt[0];
  664.  
  665.         int altespalte = alt[1];
  666.  
  667.        
  668.  
  669.         //Bestimme welche Regeln fuer Figur gelten
  670.  
  671.         //------------------------------------------------------------------------------------//
  672.  
  673.         if(figur.contains("Turm")|| figur.contains("turm")){
  674.  
  675.             int zahl = 1;
  676.  
  677.            
  678.  
  679.             if(altespalte == neuespalte){
  680.  
  681.                 if(neuezeile > altezeile){
  682.  
  683.                     for(int count = altezeile+zahl; count != neuezeile-zahl; count++){
  684.  
  685.                         int[] position = {count, altespalte};
  686.  
  687.                         if(!feldLeer(position)){
  688.  
  689.                             return false;
  690.  
  691.                         }//end if
  692.  
  693.                     }//end for
  694.  
  695.                     return true;
  696.  
  697.                 }else if(neuezeile < altezeile){
  698.  
  699.                     for(int count = altezeile-zahl; count != neuezeile+zahl; count--){
  700.  
  701.                         int[] position = {count, altespalte};
  702.  
  703.                         if(!feldLeer(position)){
  704.  
  705.                             return false;
  706.  
  707.                         }//end if
  708.  
  709.                     }//end for
  710.  
  711.                     return true;
  712.  
  713.                 }//end if
  714.  
  715.             }else if(altezeile == neuezeile){
  716.  
  717.                 if(neuespalte > altespalte){
  718.  
  719.                     for(int count = altespalte+zahl; count != neuespalte-zahl; count++){
  720.  
  721.                         int[] position = {altezeile, count};
  722.  
  723.                         if(!feldLeer(position)){
  724.  
  725.                             return false;
  726.  
  727.                         }//end if
  728.  
  729.                     }//end for
  730.  
  731.                     return true;
  732.  
  733.                 }else if(neuespalte < altespalte){
  734.  
  735.                     for(int count = altespalte-zahl; count != neuespalte+zahl; count++){
  736.  
  737.                         int[] position = {altezeile, count};
  738.  
  739.                         if(!feldLeer(position)){
  740.  
  741.                             return false;
  742.  
  743.                         }//end if
  744.  
  745.                     }//end for
  746.  
  747.                     return true;
  748.  
  749.                 }//end if
  750.  
  751.             }//end if
  752.  
  753.         //------------------------------------------------------------------------------------//
  754.  
  755.         }else if(figur.contains("Springer") || figur.contains("springer")){
  756.  
  757.             int zahl = 1;
  758.  
  759.            
  760.  
  761.             while(zahl > 2){
  762.  
  763.                 if(altezeile + zahl == neuezeile){
  764.  
  765.                     while(zahl > 2){
  766.  
  767.                         if(altespalte + zahl == neuespalte){
  768.  
  769.                             return true;
  770.  
  771.                         }else if(altespalte - zahl == neuespalte){
  772.  
  773.                             return true;
  774.  
  775.                         }//end if
  776.  
  777.                         zahl++;
  778.  
  779.                     }//end while
  780.  
  781.                 }else if(altezeile - zahl == neuezeile){
  782.  
  783.                     while(zahl > 2){
  784.  
  785.                         if(altespalte + zahl == neuespalte){
  786.  
  787.                             return true;
  788.  
  789.                         }else if(altespalte - zahl == neuespalte){
  790.  
  791.                             return true;
  792.  
  793.                         }//end if
  794.  
  795.                         zahl++;
  796.  
  797.                     }//end while
  798.  
  799.                 }else if(altespalte + zahl == neuespalte){
  800.  
  801.                     while(zahl > 2){
  802.  
  803.                         if(altespalte + zahl == neuespalte){
  804.  
  805.                             return true;
  806.  
  807.                         }else if(altespalte - zahl == neuespalte){
  808.  
  809.                             return true;
  810.  
  811.                         }//end if
  812.  
  813.                         zahl++;
  814.  
  815.                     }//end while
  816.  
  817.                 }else if(altespalte - zahl == neuespalte){
  818.  
  819.                     while(zahl > 2){
  820.  
  821.                         if(altespalte + zahl == neuespalte){
  822.  
  823.                             return true;
  824.  
  825.                         }else if(altespalte - zahl == neuespalte){
  826.  
  827.                             return true;
  828.  
  829.                         }//end if
  830.  
  831.                         zahl++;
  832.  
  833.                     }//end while
  834.  
  835.                 }else{
  836.  
  837.                     zahl++;
  838.  
  839.                 }//end if
  840.  
  841.             }//end while
  842.  
  843.         //------------------------------------------------------------------------------------//
  844.  
  845.         }else if(figur.contains("Laeufer") || figur.contains("laeufer")){
  846.  
  847.             int count;
  848.  
  849.             int zahl = 1;
  850.  
  851.             int tempspalte;
  852.  
  853.            
  854.  
  855.             if(neuezeile > altezeile){
  856.  
  857.                 for(count = altezeile+zahl; count < neuezeile; count++){
  858.  
  859.                     if(neuespalte > altespalte){
  860.  
  861.                         tempspalte = altespalte + zahl;
  862.  
  863.                         int[] position = {count, tempspalte};
  864.  
  865.                         if(!feldLeer(position)){
  866.  
  867.                             return false;
  868.  
  869.                         }
  870.  
  871.                     }else if(neuespalte < altespalte){
  872.  
  873.                         tempspalte = altespalte - zahl;
  874.  
  875.                         int[] position = {count, tempspalte};
  876.  
  877.                         if(!feldLeer(position)){
  878.  
  879.                             return false;
  880.  
  881.                         }
  882.  
  883.                     }//end if
  884.  
  885.                     zahl++;
  886.  
  887.                 }//end for
  888.  
  889.                 return true;
  890.  
  891.             }else if(neuezeile < altezeile){
  892.  
  893.                 for(count = altezeile-zahl; count > neuespalte; count--){
  894.  
  895.                     if(neuespalte > altespalte){
  896.  
  897.                         tempspalte = altespalte + zahl;
  898.  
  899.                         int[] position = {count, tempspalte};
  900.  
  901.                         if(!feldLeer(position)){
  902.  
  903.                             return false;
  904.  
  905.                         }
  906.  
  907.                     }else if(neuespalte < altespalte){
  908.  
  909.                         tempspalte = altespalte - zahl;
  910.  
  911.                         int[] position = {count, tempspalte};
  912.  
  913.                         if(!feldLeer(position)){
  914.  
  915.                             return false;
  916.  
  917.                         }
  918.  
  919.                     }//end if
  920.  
  921.                     zahl++;
  922.  
  923.                 }//end for
  924.  
  925.                 return true;
  926.  
  927.             }//end if
  928.  
  929.         //------------------------------------------------------------------------------------//
  930.  
  931.         }else if(figur.contains("Dame") || figur.contains("dame")){
  932.  
  933.             int count;
  934.  
  935.             int zahl = 1;
  936.  
  937.             int tempspalte;
  938.  
  939.            
  940.  
  941.             if(altespalte == neuespalte){
  942.  
  943.                 if(neuezeile > altezeile){
  944.  
  945.                     for(count = altezeile+zahl; count != neuezeile-zahl; count++){
  946.  
  947.                         int[] position = {count, altespalte};
  948.  
  949.                         if(!feldLeer(position)){
  950.  
  951.                             return false;
  952.  
  953.                         }//end if
  954.  
  955.                     }//end for
  956.  
  957.                     return true;
  958.  
  959.                 }else if(neuezeile < altezeile){
  960.  
  961.                     for(count = altezeile-zahl; count != neuezeile+zahl; count--){
  962.  
  963.                         int[] position = {count, altespalte};
  964.  
  965.                         if(!feldLeer(position)){
  966.  
  967.                             return false;
  968.  
  969.                         }//end if
  970.  
  971.                     }//end for
  972.  
  973.                     return true;
  974.  
  975.                 }//end if
  976.  
  977.             }else if(altezeile == neuezeile){
  978.  
  979.                 if(neuespalte > altespalte){
  980.  
  981.                     for(count = altespalte+zahl; count != neuespalte-zahl; count++){
  982.  
  983.                         int[] position = {altezeile, count};
  984.  
  985.                         if(!feldLeer(position)){
  986.  
  987.                             return false;
  988.  
  989.                         }//end if
  990.  
  991.                     }//end for
  992.  
  993.                     return true;
  994.  
  995.                 }else if(neuespalte < altespalte){
  996.  
  997.                     for(count = altespalte-zahl; count != neuespalte+zahl; count++){
  998.  
  999.                         int[] position = {altezeile, count};
  1000.  
  1001.                         if(!feldLeer(position)){
  1002.  
  1003.                             return false;
  1004.  
  1005.                         }//end if
  1006.  
  1007.                     }//end for
  1008.  
  1009.                     return true;
  1010.  
  1011.                 }//end if
  1012.  
  1013.             }else if(neuezeile > altezeile){
  1014.  
  1015.                 for(count = altezeile+zahl; count < neuezeile; count++){
  1016.  
  1017.                     if(neuespalte > altespalte){
  1018.  
  1019.                         tempspalte = altespalte + zahl;
  1020.  
  1021.                         int[] position = {count, tempspalte};
  1022.  
  1023.                         if(!feldLeer(position)){
  1024.  
  1025.                             return false;
  1026.  
  1027.                         }
  1028.  
  1029.                     }else if(neuespalte < altespalte){
  1030.  
  1031.                         tempspalte = altespalte - zahl;
  1032.  
  1033.                         int[] position = {count, tempspalte};
  1034.  
  1035.                         if(!feldLeer(position)){
  1036.  
  1037.                             return false;
  1038.  
  1039.                         }
  1040.  
  1041.                     }//end if
  1042.  
  1043.                     zahl++;
  1044.  
  1045.                 }//end for
  1046.  
  1047.                 return true;
  1048.  
  1049.             }else if(neuezeile < altezeile){
  1050.  
  1051.                 for(count = altezeile-zahl; count > neuespalte; count--){
  1052.  
  1053.                     if(neuespalte > altespalte){
  1054.  
  1055.                         tempspalte = altespalte + zahl;
  1056.  
  1057.                         int[] position = {count, tempspalte};
  1058.  
  1059.                         if(!feldLeer(position)){
  1060.  
  1061.                             return false;
  1062.  
  1063.                         }
  1064.  
  1065.                     }else if(neuespalte < altespalte){
  1066.  
  1067.                         tempspalte = altespalte - zahl;
  1068.  
  1069.                         int[] position = {count, tempspalte};
  1070.  
  1071.                         if(!feldLeer(position)){
  1072.  
  1073.                             return false;
  1074.  
  1075.                         }
  1076.  
  1077.                     }//end if
  1078.  
  1079.                     zahl++;
  1080.  
  1081.                 }//end for
  1082.  
  1083.                 return true;
  1084.  
  1085.             }//end if
  1086.  
  1087.         //------------------------------------------------------------------------------------//
  1088.  
  1089.         }else if(figur.contains("Koenig") || figur.contains("koenig")){
  1090.  
  1091.             int count;
  1092.  
  1093.             int zahl = 1;
  1094.  
  1095.             int tempspalte;
  1096.  
  1097.            
  1098.  
  1099.             if(altespalte == neuespalte){
  1100.  
  1101.                 if(neuezeile > altezeile){
  1102.  
  1103.                     for(count = altezeile+zahl; count != neuezeile-zahl; count++){
  1104.  
  1105.                         int[] position = {count, altespalte};
  1106.  
  1107.                         if(!feldLeer(position)){
  1108.  
  1109.                             return false;
  1110.  
  1111.                         }//end if
  1112.  
  1113.                     }//end for
  1114.  
  1115.                     return true;
  1116.  
  1117.                 }else if(neuezeile < altezeile){
  1118.  
  1119.                     for(count = altezeile-zahl; count != neuezeile+zahl; count--){
  1120.  
  1121.                         int[] position = {count, altespalte};
  1122.  
  1123.                         if(!feldLeer(position)){
  1124.  
  1125.                             return false;
  1126.  
  1127.                         }//end if
  1128.  
  1129.                     }//end for
  1130.  
  1131.                     return true;
  1132.  
  1133.                 }//end if
  1134.  
  1135.             }else if(altezeile == neuezeile){
  1136.  
  1137.                 if(neuespalte > altespalte){
  1138.  
  1139.                     for(count = altespalte+zahl; count != neuespalte-zahl; count++){
  1140.  
  1141.                         int[] position = {altezeile, count};
  1142.  
  1143.                         if(!feldLeer(position)){
  1144.  
  1145.                             return false;
  1146.  
  1147.                         }//end if
  1148.  
  1149.                     }//end for
  1150.  
  1151.                     return true;
  1152.  
  1153.                 }else if(neuespalte < altespalte){
  1154.  
  1155.                     for(count = altespalte-zahl; count != neuespalte+zahl; count++){
  1156.  
  1157.                         int[] position = {altezeile, count};
  1158.  
  1159.                         if(!feldLeer(position)){
  1160.  
  1161.                             return false;
  1162.  
  1163.                         }//end if
  1164.  
  1165.                     }//end for
  1166.  
  1167.                     return true;
  1168.  
  1169.                 }//end if
  1170.  
  1171.             }else if(neuezeile > altezeile){
  1172.  
  1173.                 for(count = altezeile+zahl; count < neuezeile-zahl; count++){
  1174.  
  1175.                     if(neuespalte > altespalte){
  1176.  
  1177.                         tempspalte = altespalte + zahl;
  1178.  
  1179.                         int[] position = {count, tempspalte};
  1180.  
  1181.                         if(!feldLeer(position)){
  1182.  
  1183.                             return false;
  1184.  
  1185.                         }
  1186.  
  1187.                     }else if(neuespalte < altespalte){
  1188.  
  1189.                         tempspalte = altespalte - zahl;
  1190.  
  1191.                         int[] position = {count, tempspalte};
  1192.  
  1193.                         if(!feldLeer(position)){
  1194.  
  1195.                             return false;
  1196.  
  1197.                         }
  1198.  
  1199.                     }//end if
  1200.  
  1201.                 }//end for
  1202.  
  1203.                 return true;
  1204.  
  1205.             }else if(neuezeile < altezeile){
  1206.  
  1207.                 for(count = altezeile-zahl; count > neuespalte+zahl; count--){
  1208.  
  1209.                     if(neuespalte > altespalte){
  1210.  
  1211.                         tempspalte = altespalte + zahl;
  1212.  
  1213.                         int[] position = {count, tempspalte};
  1214.  
  1215.                         if(!feldLeer(position)){
  1216.  
  1217.                             return false;
  1218.  
  1219.                         }
  1220.  
  1221.                     }else if(neuespalte < altespalte){
  1222.  
  1223.                         tempspalte = altespalte - zahl;
  1224.  
  1225.                         int[] position = {count, tempspalte};
  1226.  
  1227.                         if(!feldLeer(position)){
  1228.  
  1229.                             return false;
  1230.  
  1231.                         }
  1232.  
  1233.                     }//end if
  1234.  
  1235.                 }//end for
  1236.  
  1237.                 return true;
  1238.  
  1239.             }//end if
  1240.  
  1241.         //------------------------------------------------------------------------------------//
  1242.  
  1243.         }else if(figur.contains("Bauer") || figur.contains("bauer")){          
  1244.  
  1245.             if(feldLeer(neu)){
  1246.  
  1247.                 if(weiß){
  1248.  
  1249.                     if(altespalte == neuespalte){
  1250.  
  1251.                         if(altezeile == 1){
  1252.  
  1253.                             if((altezeile + 1 == neuezeile) || (altezeile + 2 == neuezeile)){
  1254.  
  1255.                                 return true;
  1256.  
  1257.                             }//end if
  1258.  
  1259.                         }else if(altezeile + 1 == neuezeile){
  1260.  
  1261.                             return true;
  1262.  
  1263.                         }//end if
  1264.  
  1265.                     }//end if
  1266.  
  1267.                 }else{
  1268.  
  1269.                     if(altespalte == neuespalte){
  1270.  
  1271.                         if(altezeile == 6){
  1272.  
  1273.                             if((altezeile - 1 == neuezeile) || (altezeile - 2 == neuezeile)){
  1274.  
  1275.                                 return true;
  1276.  
  1277.                             }//end if
  1278.  
  1279.                         }else if(altezeile - 1 == neuezeile){
  1280.  
  1281.                             return true;
  1282.  
  1283.                         }//end if
  1284.  
  1285.                     }//end if
  1286.  
  1287.                 }//end if
  1288.  
  1289.             }else{
  1290.  
  1291.                 if(weiß){
  1292.  
  1293.                     if(altezeile + 1 == neuezeile){
  1294.  
  1295.                         if((altespalte + 1 == neuespalte) || (altespalte - 1 == neuespalte)){
  1296.  
  1297.                             return true;
  1298.  
  1299.                         }//end if
  1300.  
  1301.                     }//end if
  1302.  
  1303.                 }else{
  1304.  
  1305.                     if(altezeile - 1 == neuezeile){
  1306.  
  1307.                         if((altespalte + 1 == neuespalte) || (altespalte - 1 == neuespalte)){
  1308.  
  1309.                             return true;
  1310.  
  1311.                         }//end if
  1312.  
  1313.                     }//end if
  1314.  
  1315.                 }//end if
  1316.  
  1317.             }//end if
  1318.  
  1319.         //------------------------------------------------------------------------------------//
  1320.  
  1321.         }//end if
  1322.  
  1323.         return false;
  1324.  
  1325.     }
  1326.  
  1327.  
  1328.  
  1329.     //Pruefe ob man die Figur schlagen kann
  1330.  
  1331.     public static boolean schlagen(int[] feld, boolean weiß){
  1332.  
  1333.         if(weiß){
  1334.  
  1335.             if(!feldLeer(feld)){
  1336.  
  1337.                 if(!brett[feld[0]][feld[1]].contains("W")){
  1338.  
  1339.                     if(brett[feld[0]][feld[1]].contains("Koenig")){
  1340.  
  1341.                         schachMatt = true;
  1342.  
  1343.                         return true;
  1344.  
  1345.                     }//end if
  1346.  
  1347.                     return true;
  1348.  
  1349.                 }//end if
  1350.  
  1351.             }//end if
  1352.  
  1353.             return false;
  1354.  
  1355.         }else{
  1356.  
  1357.             if(!feldLeer(feld)){
  1358.  
  1359.                 if(!brett[feld[0]][feld[1]].contains("S")){
  1360.  
  1361.                     if(brett[feld[0]][feld[1]].contains("Koenig")){
  1362.  
  1363.                         schachMatt = true;
  1364.  
  1365.                         return true;
  1366.  
  1367.                     }//end if
  1368.  
  1369.                     return true;
  1370.  
  1371.                 }//end if
  1372.  
  1373.             }//end if
  1374.  
  1375.             return false;
  1376.  
  1377.         }//end if
  1378.  
  1379.     }
  1380.  
  1381.    
  1382.  
  1383.     //Pruefe ob Bauer das ende erreicht hat und gegen Dame getauscht wird
  1384.  
  1385.     public static boolean bauerDameTausch(int[] feld, boolean weiß){
  1386.  
  1387.         boolean ergebnis = false;
  1388.  
  1389.        
  1390.  
  1391.         if(weiß){
  1392.  
  1393.             if(feld[0] == 7){
  1394.  
  1395.                 ergebnis = true;
  1396.  
  1397.             }//end if
  1398.  
  1399.         }else{
  1400.  
  1401.             if(feld[0] == 0){
  1402.  
  1403.                 ergebnis = true;
  1404.  
  1405.             }//end if
  1406.  
  1407.         }//end if
  1408.  
  1409.         return ergebnis;
  1410.  
  1411.     }
  1412.  
  1413.    
  1414.  
  1415.     //Ziehe Figur auf neues Feld
  1416.  
  1417.     public static void ziehen(int[] altePosition, int[] neuePosition, boolean neueDame, char prefix){
  1418.  
  1419.         String tempFigur = brett[altePosition[0]][altePosition[1]];
  1420.  
  1421.        
  1422.  
  1423.         if(neueDame){
  1424.  
  1425.             if(bestimmePosition(prefix+"Dame") != null){
  1426.  
  1427.                 brett[altePosition[0]][altePosition[1]] = "";
  1428.  
  1429.                 brett[neuePosition[0]][neuePosition[1]] = prefix+"Dame"+anzahlDamen;
  1430.  
  1431.                 anzahlDamen++;
  1432.  
  1433.             }//end if
  1434.  
  1435.         }else{
  1436.  
  1437.             brett[altePosition[0]][altePosition[1]] = "";
  1438.  
  1439.             brett[neuePosition[0]][neuePosition[1]] = tempFigur;
  1440.  
  1441.         }//end if
  1442.  
  1443.     }
  1444.  
  1445.    
  1446.  
  1447.     //Pruefe ob 1D-Array object enthält
  1448.  
  1449.     public static boolean contains(String[] array, String object){
  1450.  
  1451.         for(int count = 0; count < array.length; count++){
  1452.  
  1453.             if(array[count].equalsIgnoreCase(object)){
  1454.  
  1455.                 return true;
  1456.  
  1457.             }//end if
  1458.  
  1459.         }//end for
  1460.  
  1461.         return false;
  1462.  
  1463.     }
  1464.  
  1465.    
  1466.  
  1467.     //Zeige SpielBrett
  1468.  
  1469.     public static void zeigeSpielbrett(boolean weiß){
  1470.  
  1471.         int zahl = 7;
  1472.  
  1473.        
  1474.  
  1475.         if(weiß){
  1476.  
  1477.             for(int zeile = 7; zeile >= 0; zeile--){
  1478.  
  1479.                 println("");
  1480.  
  1481.                 print("|");
  1482.  
  1483.                 for(int count = 0; count < 97; count++){
  1484.  
  1485.                     print("-");
  1486.  
  1487.                 }//end for
  1488.  
  1489.                 println("|");
  1490.  
  1491.                 print(zahlen[zahl]+" |");
  1492.  
  1493.                 zahl--;
  1494.  
  1495.                 for(int spalte = 0; spalte < 8; spalte++){
  1496.  
  1497.                     String rest;
  1498.  
  1499.                     if(brett[zeile][spalte].isEmpty()){
  1500.  
  1501.                         rest = fuelleRest(10);
  1502.  
  1503.                         print(rest);
  1504.  
  1505.                     }else{
  1506.  
  1507.                         int fehlt = wievielFehlt(brett[zeile][spalte]);
  1508.  
  1509.                         rest = fuelleRest(fehlt);
  1510.  
  1511.                         print(brett[zeile][spalte]+rest);
  1512.  
  1513.                     }//end if
  1514.  
  1515.                     print("|");
  1516.  
  1517.                 }//end for
  1518.  
  1519.             }//end for
  1520.  
  1521.         }else{
  1522.  
  1523.             for(int zeile = 0; zeile < 8; zeile++){
  1524.  
  1525.                 println("");
  1526.  
  1527.                 print("|");
  1528.  
  1529.                 for(int count = 0; count < 97; count++){
  1530.  
  1531.                     print("-");
  1532.  
  1533.                 }//end for
  1534.  
  1535.                 println("|");
  1536.  
  1537.                 print(zahlen[zahl]+" |");
  1538.  
  1539.                 zahl--;
  1540.  
  1541.                 for(int spalte = 7; spalte >= 0; spalte--){
  1542.  
  1543.                     String rest;
  1544.  
  1545.                     if(brett[zeile][spalte].isEmpty()){
  1546.  
  1547.                         rest = fuelleRest(10);
  1548.  
  1549.                         print(rest);
  1550.  
  1551.                     }else{
  1552.  
  1553.                         int fehlt = wievielFehlt(brett[zeile][spalte]);
  1554.  
  1555.                         rest = fuelleRest(fehlt);
  1556.  
  1557.                         print(brett[zeile][spalte]+rest);
  1558.  
  1559.                     }//end if
  1560.  
  1561.                     print("|");
  1562.  
  1563.                 }//end for
  1564.  
  1565.             }//end for
  1566.  
  1567.         }//end if
  1568.  
  1569.         println("");
  1570.  
  1571.         print("|");
  1572.  
  1573.         for(int count = 0; count < 97; count++){
  1574.  
  1575.             print("-");
  1576.  
  1577.         }//end for
  1578.  
  1579.         println("|");
  1580.  
  1581.        
  1582.  
  1583.         //Zeige Buchstaben am unteren Rand
  1584.  
  1585.         print("  |");
  1586.  
  1587.         for(int feld = 0; feld < 8; feld++){
  1588.  
  1589.             String rest = fuelleRest(9);
  1590.  
  1591.             print(buchstaben[feld]+rest);
  1592.  
  1593.             print("|");
  1594.  
  1595.         }//end for
  1596.  
  1597.         println("");
  1598.  
  1599.     }
  1600.  
  1601.    
  1602.  
  1603.     //Pruefe laenge des Strings und gebe zurueck, wieviel bis auf 10 fehlt
  1604.  
  1605.     public static int wievielFehlt(String msg){
  1606.  
  1607.         int laenge = msg.length();
  1608.  
  1609.         int fehlt = 10 - laenge;
  1610.  
  1611.         return fehlt;
  1612.  
  1613.     }
  1614.  
  1615.    
  1616.  
  1617.     //Erstelle fuellstring, damit feld insgesamt 10 lang ist
  1618.  
  1619.     public static String fuelleRest(int laenge){
  1620.  
  1621.         String rest = "";
  1622.  
  1623.        
  1624.  
  1625.         for(int count = 0; count <= laenge; count++){
  1626.  
  1627.             rest = rest + " ";
  1628.  
  1629.         }//end for
  1630.  
  1631.         return rest;
  1632.  
  1633.     }
  1634.  
  1635.    
  1636.  
  1637.     //Ist fuer meine schreibfaulheit ;)
  1638.  
  1639.     public static void print(String msg){
  1640.  
  1641.         System.out.print(msg);
  1642.  
  1643.     }
  1644.  
  1645.     public static void println(String msg){
  1646.  
  1647.         System.out.println(msg);
  1648.  
  1649.     }
  1650.  
  1651. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!