API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 25th, 2014
132
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.15 KB | None | 0 0
raw download clone embed print report
  1. public class ProThello2{
  2.  
  3.  
  4. // 1 c)
  5. // Variable: Zustand, bzw. Farbe
  6. // Für jeden Zustand, bzw. Farbe eines Spielsteins definieren
  7. // Sie eine (ausnahmsweise!) static Variable. Diese können
  8. // Sie dann in jeder static Prozedur oder static Funktion
  9. // aufrufen.
  10.  
  11. static char schwarz= 's';
  12. static char weiss = 'w';
  13. static char leer = ' ';
  14.  
  15. // Variable: Variable String whos_turn
  16. // Variable, die angibt wessen Zug es ist. Schwarz fängt
  17. // bei Spielanfang an, desshalb ist black_turn als "default" definiert
  18.  
  19. static char turn = schwarz;
  20.  
  21.  
  22. /**
  23. * Hauptprozedur, die das Spiel startet,
  24. * bzw. alle Funktionen und Prozeduren testet.
  25. * @param args Parameter beim Aufruf durch die Kommandozeile
  26. * */
  27. public static void main(String[] args){
  28.  
  29. // Array 2D: Definition des Spielfelds
  30. // Spielfeld als ein 2-dimensionales Array von char
  31.  
  32. char field [][] = new char [8][8]; // array mit 8x8 Stellen
  33.  
  34. clear_field(field);
  35. draw_field(field);
  36. set_validated_stone(field,4,2);
  37. set_validated_stone(field,3,2);
  38. draw_field(field);
  39. surrounding_right(field,3,5);
  40. surrounding_left(field,3,5);
  41.  
  42. }
  43.  
  44. // Fügen Sie hier alle Ihre Prozeduren und Funktionen
  45. // zur Lösung ein
  46.  
  47. // b) brauchbare Infos
  48. // Spielfeld 8x8: char [0][0] bis char [7][7] Informationen
  49. // über Zustände: Ist Feld schwarz, weiß, oder leer?
  50. // Setzten von Steinen: Steine ändern ihre Farbe, wenn
  51. // sie von 2 Steinen der jeweiligen anderen Farbe eingeschlossen
  52. // sind.
  53.  
  54.  
  55.  
  56. // 1 d) Initialisieren Spielfeld in Prozedur
  57.  
  58. /** Procedure: Prozedur clear_field
  59. * In dieser Prozedur wird das Spielfeld initialisiert und die Startbelegung aufgestellt
  60. * @param field, der das Spielfeld repräsentiert
  61. */
  62.  
  63. static void clear_field(char field [][]){
  64.  
  65. // Alle Felder mit " " füllen.
  66.  
  67. // For-Loop: for-Schleife 1
  68. // für int i = 0, i <= field.length, soll i um 1 erhöht
  69. // werden.
  70.  
  71. for (int i = 0; i < field.length; i++){
  72.  
  73. // For-Loop: for-Schleife 2
  74. // Für int j = 0; j< field[i].length, soll j um 1 erhöht
  75. // werden.
  76.  
  77. for (int j = 0; j < field[i].length; j++){
  78.  
  79. // Feld auf leer setzen
  80. // durch field [i][j] wird jedes Feld einzeln mit "leer" (' ')
  81. // gefüllt
  82.  
  83. field[i][j] = leer;
  84.  
  85. }
  86. }
  87.  
  88.  
  89. // Startbelegung
  90. // für die Startbelegung wird Feld D4 ([3][3]), E4 ([4][3]),
  91. // D5 ([3][4]) und E5 ([4][4]) jeweils mit schwarz oder
  92. // weiß, entsprechend des Regelwerts, gefüllt.
  93.  
  94. field[3][3] = schwarz;
  95. field[3][4] = weiss; // s w
  96. field[4][4] = schwarz; // w s
  97. field[4][3] = weiss;
  98.  
  99. } // ende clear_field
  100.  
  101.  
  102. // 1 e) Spielfeld auf Konsole darstellen
  103.  
  104. /** Procedure: Prozedur draw_field
  105. * In diese Prozedur wird das Spielfeld auf die Konsole
  106. * ausgegeben
  107. * @param field, der das Spielfeld im aktuellen Zustand representiert
  108. */
  109.  
  110. static void draw_field(char field [][]){
  111.  
  112. // For-Loop: for-Schleife 1
  113. // für (int i; i < field.length, soll i um 1 erhöht werden
  114.  
  115. for (int i = 0; i < field.length; i++){
  116.  
  117. // Überschrift ( A - H)
  118. // 'A' + i wird auf die Konsole ausgeben. So entsteht
  119. // Eine Überschrift der Spalten A - H des Spielfeldes
  120.  
  121. // For-Loop: for-Schleife 2
  122. // für int j = 0; j < field[i].length, soll j um 1 erhöht
  123. // werden
  124.  
  125. for (int j = 0; j < field[i].length; j++){
  126.  
  127. // Spielfeld ausgeben
  128. // Mit field [i][j] wird durch die for-Schleifen, das
  129. // Spielfeld ausgegeben.
  130.  
  131. System.out.print("| " + field[i][j] + " ");
  132. }
  133.  
  134. System.out.println("|"); // Nach jeder Zeile, ein Zeilenumbruch
  135. System.out.println("");
  136. }
  137.  
  138.  
  139.  
  140. } // ende draw_field
  141.  
  142.  
  143. // 1 f)
  144.  
  145. /** Procedure: Prozedur set_stone
  146. * In dieser Prozedur soll ein Stein, an angegebener Stelle, gesetzt
  147. * werden
  148. * @param field, der das Spielfeld repräsentiert
  149. * @param x, als X-Koordinate
  150. * @param y, als Y-Koordinate
  151. */
  152. /*
  153. static void set_stone(char field[][], int x, int y){
  154.  
  155.  
  156. // If-Else: if-Abfrage: Wessen Zug?
  157. // Falls die String Variable whos_turn true ist, ist
  158. // schwarz dran: Es wird ein schwarzer Stein gelegt.
  159. // Andernfalls wird ein weisser Stein gelegt.
  160.  
  161. if (whos_turn){
  162.  
  163. // field an der Position x,y auf schwarz
  164.  
  165. field[x][y] = schwarz;
  166.  
  167. // nach dem Zug wird die String Variable whos_turn
  168. // auf "white_turn" (weisser Zug) gesetzt
  169.  
  170. whos_turn = false;
  171.  
  172. }
  173. else {
  174.  
  175. field[x][y] = weiss;
  176. whos_turn = true;
  177. }
  178.  
  179. } // ende set_stone
  180.  
  181.  
  182. */
  183.  
  184.  
  185.  
  186.  
  187. // 1 g)
  188.  
  189. /** Procedure: Prozedur turn_stone
  190. * Prozedur, die einen vorhandenen Stein umdreht
  191. * @param field, der das Spielfeld repräsentiert
  192. * @param x, Koordinate
  193. * @param y, Koordinate
  194. */
  195.  
  196. static void turn_stone(char field [][], int x, int y){
  197.  
  198. // If-Else: if-Abfrage
  199. // Wenn ein Stein an einer angegebenen Stelle schwarz
  200. // ist, soll er auf weiss gesetzt werden falls nicht,
  201. // dann umgekehrt
  202.  
  203. if (field[x][y] == schwarz){
  204.  
  205. field[x][y] = weiss;
  206. }
  207. else {
  208.  
  209. field[x][y] = schwarz;
  210. }
  211.  
  212. } // ende turn_stone
  213.  
  214.  
  215. // 2 a + b) Position prüfen
  216.  
  217. static boolean in_field(char field[][], int x, int y){
  218.  
  219.  
  220. return(x < field.length && y < field[0].length
  221. && x > 0 && y > 0);
  222.  
  223. }
  224.  
  225.  
  226.  
  227.  
  228. /** Procedure: set_validated_stone
  229. * Kopie der Setz-Prozedur aus 1 f) mit Prüfung, ob angegebener
  230. * Stein im Feld liegt.
  231. * @param field, der das Spielfeld repräsentiert
  232. * @param x, Koordinate
  233. * @param y, Koordinate
  234. */
  235.  
  236. static void set_validated_stone(char field[][], int x, int y){
  237.  
  238. // If: if-Abfrage: Wessen Zug? + Position
  239. // turn Variable: wahr -> schwarz ist dran. false
  240. // -> weiss ist dran + ist angegebener Position im Spielfeld?
  241.  
  242. if(in_field(field,x,y)){
  243.  
  244. if(is_empty(field,x,y)){
  245.  
  246. if(my_color(field,x,y,turn) == false){
  247.  
  248. if(surrounding_right(field,x,y) || surrounding_left(field,x,y)){
  249.  
  250. if(turn == schwarz){
  251.  
  252. field[x][y] = schwarz;
  253. turn = weiss; // weiss ist als nächstes am Zug
  254.  
  255. }
  256. else {
  257.  
  258. field[x][y] = weiss;
  259. turn = schwarz; // schwarz ist als nächstes am Zug
  260.  
  261. }
  262.  
  263. }
  264. }
  265. }
  266. }
  267.  
  268. } // ende set_validated_stone
  269.  
  270.  
  271.  
  272. // 2 c) Farbe an Position?
  273.  
  274. /** Function: Funktion boolean my_color
  275. * In dieser Funktion wird die Farbe eines Steins, an
  276. * angegebener Position ermittelt
  277. *
  278. * @param char field[][]:
  279. * das Spielfeld
  280. *
  281. * @param int x: Koordinate @param int
  282. * y: Koordinate
  283. *
  284. */
  285.  
  286. static boolean my_color(char field [][], int x, int y, char turn){
  287.  
  288. // Variable: String Variable my_color
  289. // vorsichtshalter auf false, für den Fehlerfall
  290.  
  291. boolean my_color = false;
  292.  
  293. // If-Else: if-Abfrage:
  294. // Es wird abgefragt, ob der Stein, an angegebener Stelle,
  295. // schwarz ist. Je nachdem wessen Zug es ist, wird entschieden,
  296. // ob der jeweilige Stein self (eigener) oder enemy (gegnerisch) ist
  297.  
  298.  
  299. if (field[x][y] == turn){
  300.  
  301. my_color = true;
  302. }
  303. else {
  304.  
  305. my_color = false;
  306. }
  307.  
  308.  
  309. // Rückgabewert: Farbe
  310. return my_color;
  311.  
  312. } // ende my_color
  313.  
  314.  
  315. // 2 d)
  316.  
  317. /** Function: Funktion is_empty
  318. * Diese Funktion gibt an, ob an angegebener Stelle kein
  319. * Stein liegt, d.h. ob dieser Platz frei ist.
  320. * @param char field [][]: das Spielfeld
  321. * @param int x: Koordinate
  322. * @param int y: Koordinate
  323. */
  324.  
  325. static boolean is_empty(char field[][], int x, int y){
  326.  
  327. // Variable: String Variable state
  328.  
  329. boolean state;
  330.  
  331. // If-Else: if-Abfrage: Stelle leer?
  332. // Wenn der Array, an angegebener Stelle leer (' ') ist,
  333. // wird der Rückgabestring auf "empty" gesetzt. Andernfalls
  334. // auf "full"
  335.  
  336. if (field[x][y] == leer){
  337.  
  338. state = true;
  339. }
  340. else {
  341.  
  342. state = false;
  343. }
  344.  
  345. // Rückgabewert: state
  346. return state;
  347.  
  348. } // ende is_empty
  349.  
  350.  
  351.  
  352. // 2 e) nach rechts prüfen
  353.  
  354. /** Funktion: Funktion surrounding_right
  355. * In dieser Funktion wird geprüft, ob ein neuer Stein
  356. * rechts in horizontaler Richtung gegnerische (enemy)
  357. * Steine einschließt.
  358. * @param char field: das Spielfeld
  359. * @param int x: Koordinate, des betrachteten Steins
  360. * @param int x: Koordinate des betrachteten Steins
  361. * Rückgabewert: boolean surrounding
  362. */
  363.  
  364. static boolean surrounding_right(char field[][], int x, int y){
  365.  
  366. // Variable: boolean Variable surrounding für return
  367. // vorsichtshalber auf false, damit nicht im Fehlerfall
  368. // fällschlicherweise true geliefert wird
  369.  
  370. boolean surrounding = false;
  371.  
  372. // For-Schleife: for-Schleife 1
  373. // für int i = x; i < field[i].length, sol i um 1 erhöht
  374. // werden. So geht die for-Schleife ab dem angegebenen
  375. // Stein nach rechts durch das field
  376.  
  377.  
  378. while (y < field[x].length && my_color(field,x,y,turn)== false){
  379.  
  380. y++;
  381.  
  382. if(is_empty(field,x,y)== false){
  383.  
  384. my_color(field,x,y,turn);
  385. surrounding = true;
  386.  
  387. }
  388. else {
  389.  
  390. surrounding = false;
  391. }
  392.  
  393.  
  394. }
  395.  
  396. System.out.println(surrounding);
  397. return surrounding;
  398. }
  399.  
  400.  
  401.  
  402. // 2 f) nach links prüfen
  403.  
  404. /** Funktion: Funktion surrounding_left
  405. * In dieser Funktion wird geprüft, ob ein neue Stein
  406. * links in horizontaler Richtung gegnerische (enemy)
  407. * Steine einschließt.
  408. * @param field: das Spielfeld
  409. * @param x: Koordinate, des betrachteten Steins
  410. * @param x: Koordinate des betrachteten Steins
  411. * Rückgabewert: surrounding
  412. */
  413.  
  414. static boolean surrounding_left(char field[][], int x, int y){
  415.  
  416. // Variable: boolean Variable surrounding für return
  417. // vorsichtshalber auf false, damit nicht im Fehlerfall
  418. // fällschlicherweise true geliefert wird
  419.  
  420. boolean surrounding = false;
  421.  
  422. // For-Schleife: for-Schleife
  423. // Für int i = y; i < field.length, soll i um 1 veringert werden
  424. // werden.
  425.  
  426.  
  427. while (y > 0 && my_color(field,x,y,turn)== false){
  428.  
  429. y--;
  430. if (is_empty(field,x,y)== false){
  431.  
  432. my_color(field,x,y,turn);
  433. surrounding = true;
  434. }
  435. else {
  436.  
  437. surrounding = false;
  438. }
  439.  
  440.  
  441. }
  442.  
  443. System.out.println(surrounding);
  444.  
  445. for (int i = y; i >= 0; i--){
  446.  
  447. // If: if-Abfrage 1
  448. // Wenn die geprüfte Stelle NICHT leer ist, wird weiter
  449. // gemacht
  450.  
  451. if (is_empty(field,x,i) == false){
  452.  
  453. if(my_color(field,x,y-1,turn)== false){
  454.  
  455. // If: if-Abfrage 2
  456. // Wenn die Farbe des geprüften Stein die eigene ist,
  457. // soll surrounding ture gesetzt werden andernfalls auf
  458. // false. Es wird so geprüft, dass nur weiter geprüft
  459. // wird, wenn keine leere Stelle aufgekommen ist.
  460.  
  461. surrounding = true;
  462.  
  463. }
  464. else {
  465.  
  466. surrounding = false;
  467. }
  468.  
  469. }
  470. }
  471.  
  472. return surrounding;
  473. }
  474.  
  475.  
  476. }
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!