Umstrunktorierung Spiellogik

src/Spiellogik.c

@@ -0,0 +1,69 @@
+#define _CRT_SECURE_NO_WARNINGS // to write faster
+#define re return 
+#define N 20 // size of Play Field
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<time.h>
+#include<stdbool.h>
+
+
+int win(int realU[N][N]){
+    int groesste = 0;
+    for(int i = 0; i < N; i++){
+        for(int j = 0; j < N; j++){
+            if(realU[i][j] > groesste && realU[i][j] != (N * N ) + 1){
+                groesste = realU[i][j];
+            }
+        }
+    }
+    if(groesste == (N * N) - 1){
+        return 1;
+    }
+    else{
+        return 0;
+    }
+}
+
+//Die Funktion überprüft, ob das Feld bereits vom Schlangenkoerper besetzt ist.
+int feldFrei(int realU[N][N], int ii, int jj){
+    if (realU[ii][jj] == 0)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+int lose(int realU[N][N], char richtung){
+    int groesste = 0; //Suche den Kopf der Schlange
+    int ii, jj;
+   for(int i = 0; i < N ; i++){
+    for(int j = 0; j < N; j++){
+        if (realU[i][j] > groesste && realU[i][j] != (N * N) + 1){
+            groesste = realU[i][j];
+            ii = i;
+            jj = j;
+        }
+    }
+   }
+
+   switch (richtung){
+    case 'u': //Ueberpruefe ob eine Bewegung nach oben moeglich ist
+        if(realU[ii - 1][jj] != (N*  N) + 1 && feldFrei(realU, ii-1, jj) == 1){
+        return 1;break;
+        }
+    case 'd': //Ueberpruefe ob eine Bewegung nach unten moeglich ist
+        if(realU[ii + 1][jj] != N || feldFrei(realU, ii+1, jj) == 1){
+            return 1;break;
+        }
+    case 'l': //Ueberpruefe ob eine Bewegung nach links moeglich ist
+        if(realU[ii][jj-1] != 0 || feldFrei(realU, ii, jj-1) == 1){
+            return 1;break;
+        }
+    case 'r': //Ueberpruefe ob eine Bewegung nach rechts moeglich ist
+        if(realU[ii][jj + 1] > N || feldFrei(realU, ii, jj+1) == 1){
+            return 1;break;
+        }
+   }
+    return 0;
+}

src/Umgebung.c

@@ -145,65 +145,4 @@ void Apfel(int realU[N][N]){
     }  
 }
 
-int win(int realU[N][N]){
-    int groesste = 0;
-    for(int i = 0; i < N; i++){
-        for(int j = 0; j < N; j++){
-            if(realU[i][j] > groesste && realU[i][j] != (N * N ) + 1){
-                groesste = realU[i][j];
-            }
-        }
-    }
-    if(groesste == (N * N) - 1){
-        return 1;
-    }
-    else{
-        return 0;
-    }
-}
-
-//Die Funktion überprüft, ob das Feld bereits vom Schlangenkoerper besetzt ist.
-int feldFrei(int realU[N][N], int ii, int jj){
-    if (realU[ii][jj] == 0)
-    {
-        return 1;
-    }
-    return 0;
-}
 
-int lose(int realU[N][N], char richtung){
-    int groesste = 0; //Suche den Kopf der Schlange
-    int ii, jj;
-   for(int i = 0; i < N ; i++){
-    for(int j = 0; j < N; j++){
-        if (realU[i][j] > groesste && realU[i][j] != (N * N) + 1){
-            groesste = realU[i][j];
-            ii = i;
-            jj = j;
-        }
-    }
-   }
-
-   switch (richtung){
-    case 'u': //Ueberpruefe ob eine Bewegung nach oben moeglich ist
-        if(realU[ii - 1][jj] != (N*  N) + 1 && feldFrei(realU, ii-1, jj) == 1){
-        return 1;break;
-        }
-    case 'd': //Ueberpruefe ob eine Bewegung nach unten moeglich ist
-        if(realU[ii + 1][jj] != N || feldFrei(realU, ii+1, jj) == 1){
-            return 1;break;
-        }
-    case 'l': //Ueberpruefe ob eine Bewegung nach links moeglich ist
-        if(realU[ii][jj-1] != 0 || feldFrei(realU, ii, jj-1) == 1){
-            return 1;break;
-        }
-    case 'r': //Ueberpruefe ob eine Bewegung nach rechts moeglich ist
-        if(realU[ii][jj + 1] > N || feldFrei(realU, ii, jj+1) == 1){
-            return 1;break;
-        }
-   }
-    
-    return 0;
-   
-   
-}