highscores.txt

@@ -1,5 +1,3 @@
 Silvana;9944
 hannes;9910
-silvana;9865
-player2;4983
 player1;3999

makefile

@@ -1,66 +1,66 @@
 CC = gcc
+FLAGS = -g -Wall -lm
 
+ifeq ($(OS),Windows_NT)
+	include makefile_windows.variables
+else
+	UNAME = $(shell uname)
+	ifeq ($(UNAME),Linux)
+		include makefile_linux.variables
+	else
+		include makefile_mac.variables
+	endif
+endif
 
 raylibfolder = ./raylib
 unityfolder = ./unity
 
-
-FLAGS = -g -Wall -I$(unityfolder)
-
-
-ifeq ($(OS),Windows_NT)
-include makefile_windows.variables
-else
-UNAME := $(shell uname)
-ifeq ($(UNAME),Linux)
-include makefile_linux.variables
-else
-include makefile_mac.variables
-endif
-endif
-
 # --------------------------
-# Objektdateien
+# Initiales Programm bauen (zum ausprobieren)
 # --------------------------
-program_obj_files := stack.o bintree.o numbers.o timer.o highscore.o
-
-
-%.o: %.c
-	$(CC) $(FLAGS) -c $< -o $@
-
-
-doble: main.o $(program_obj_files)
-	$(CC) $(FLAGS) $^ -o doble
-
-
 doble_initial:
 	$(CC) -o doble_initial $(BINARIES)/libdoble_complete.a
 
+# --------------------------
+# Selbst implementiertes Programm bauen
+# --------------------------
+program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o
+
+doble : main.o $(program_obj_files)
+	$(CC) $(FLAGS) $^ -o doble
+
+$(program_obj_filesobj_files): %.o: %.c
+	$(CC) -c $(FLAGS) $^ -o $@
+
 # --------------------------
 # Unit Tests
 # --------------------------
+unity_src = $(unityfolder)/unity.c
 
-unitTests:
+unitTests: numbersTest stackTest bintreeTest
-	@echo "needs to be implemented"
+	# ./runNumbersTest
+	# ./runStackTest
+	./runBintreeTest
 
+numbersTest: numbers.o bintree.o stack.o numbersTest.c $(unity_src)
+	$(CC) $(CFLAGS) $(LDFLAGS) -I$(unityfolder) $^ -o runNumbersTest
 
-binTreeTest: stack.o bintree.o binTreeTest.c $(unityfolder)/unity.c
+stackTest: stack.o stackTest.c $(unity_src)
-	$(CC) $(FLAGS) -o runbinTreeTest binTreeTest.c bintree.o stack.o $(unityfolder)/unity.c
+	$(CC) $(CFLAGS) $(LDFLAGS) -I$(unityfolder) $^ -o runStackTests
 
+binTreeTest: bintree.o binTreeTest.c $(unity_src) stack.o
+	$(CC) $(CFLAGS) $(LDFLAGS) -I$(unityfolder) $^ -o runBinTreeTest
 
-test_numbers: numbers_no_tree.o bintree.o stack.o test_numbers.c $(unityfolder)/unity.c
+%.o: %.c
-	$(CC) $(FLAGS) -o run_numbersTests test_numbers.c numbers_no_tree.o bintree.o stack.o $(unityfolder)/unity.c
+	$(CC) -c $(CFLAGS) $< -o $@
 
 
-test_stack: stack.o test_stack.c $(unityfolder)/unity.c
-	$(CC) $(FLAGS) -o runstackTests test_stack.c stack.o $(unityfolder)/unity.c
-
 # --------------------------
-# Cleaning
+# Clean
 # --------------------------
 clean:
 ifeq ($(OS),Windows_NT)
-	del /f *.o doble runstackTests run_numbersTests runbintreeTests
+	del /f *.o doble
 else
-	rm -f *.o doble runstackTests run_numbersTests runbintreeTests
+	rm -f *.o doble
-endif
+endif

numbers.c

@@ -17,88 +17,85 @@
 // Returns len random numbers between 1 and 2*len in random order,
 // all different, except for exactly one duplicate (two entries the same).
 // Uses your binary search tree implementation to check for duplicates while generating numbers.
-#include <stdlib.h>
-#include <stdio.h>
-#include <time.h>
-#include "numbers.h"
-#include "bintree.h"
-
-int compareFct(const void *a, const void *b)
-  {
-      return (*(int *)a > *(int *)b) - (*(int *)a < *(int *)b); // a und b werden in int konvertiert und deren Werte miteinander verglichen
-                                                                // returns 1 for a>b or -1 for a<b
-                                                                // in bintree.c wird ueberprueft, ob compare eine positive oder eine negative Zahl zurueckgibt,
-                                                                // wenn a groeßer b, positiv und dann wird links nach Teilbauemen gesucht
-  }
-
-// Erzeugt len Zufallszahlen zwischen 1 und 2*len
-// alle einzigartig, außer genau ein Duplikat
 unsigned int *createNumbers(unsigned int len)
 {
-    if (len < 2)
+  if (len < 2)
-        return NULL;
+    return NULL;
 
-    srand((unsigned int)time(NULL));
+  srand(time(NULL));
 
-    unsigned int *numbers = malloc(len * sizeof(unsigned int));
-    if (!numbers)
-        return NULL;
 
-    TreeNode *root = NULL; // Baum anfänglich leer
+  unsigned int *numbers = malloc(len * sizeof(unsigned int));
-    unsigned int count = 0;
+  if (!numbers)
+    return NULL;
 
-    // Zufallszahlen generieren, bis das Array voll ist
+  TreeNode *root = NULL; // Baum anfänglich leer
-    while (count < len)
+  unsigned int count = 0;
-    {
-        unsigned int random = (rand() % (2 * len)) + 1;
-        int duplicate = 0; // Anfangswert für Duplikat-Check
 
-        root = addToTree(root, &random, sizeof(random), compareFct, &duplicate);
+  // Zufallszahlen generieren, bis das Array voll ist
+  while (count < len) {
+    unsigned int random = (rand() % (2 * len)) + 1;
 
-        if (root == NULL)
+    int duplicate = 0; // Anfangswert für Duplikat-Check
-        {
+    root = addToTree(root, &random, sizeof(random), compareFct, &duplicate);
-            free(numbers);
-            return NULL;
-        }
 
-        if (!duplicate)
+    if (root == NULL) {
-        {
+      free(numbers);
-            numbers[count++] = random;
+      return NULL;
-        }
-        // duplicate == 1 → Zahl existiert schon, neue Zahl generieren
     }
 
-    // genau ein Duplikat erzeugen
+    if (!duplicate) { // Zahl war neu → ins Array einfügen
-    unsigned int idx1 = rand() % len;
+      numbers[count++] = random;
-    unsigned int idx2 = rand() % len;
+    }
-    while (idx2 == idx1)
+    // duplicate == 1 → Zahl existiert schon, neue Zahl generieren
-        idx2 = rand() % len;
+  }
 
-    numbers[idx2] = numbers[idx1];
+  // Jetzt len eindeutige Zahlen erzeugt → ein Duplikat erzwingen
+  unsigned int idx1 = rand() % len;
+  unsigned int idx2 = rand() % len;
+  while (idx2 == idx1)                // sicherstellen, dass es eine andere Position ist
+    idx2 = rand() % len;
 
-    // Baum wieder freigeben
+  numbers[idx2] = numbers[idx1];
-    clearTree(root);
 
-    return numbers;
+  // Baum wieder freigeben
+  clearTree(root);
+
+  return numbers;
+}
+
+  // Jetzt len eindeutige Zahlen erzeugt ⇒ wir müssen ein Duplikat erzwingen
+  unsigned int idx1 = rand() % len;
+  unsigned int idx2 = rand() % len;
+  while (idx2 == idx1)
+    idx2 = rand() % len;
+
+  numbers[idx2] = numbers[idx1];   // zweites Exemplar
+
+  clearTree(root);
+  return numbers;
 }
 
 
-// findet die eine doppelte Zahl im Array
+// Returns only the only number in numbers which is present twice. Returns zero on errors.
 unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
 {
-    if (!numbers || len < 2)
+  if(len>0)
-        return 0;
-
-    for (unsigned int i = 0; i < len; i++)
     {
-        for (unsigned int j = i + 1; j < len; j++)
+    unsigned int duplicate = 0;
-        {
+    for(unsigned int i=0;i<len;i++)
-            if (numbers[i] == numbers[j])
+      {
-                return numbers[i];
+        unsigned int v1 = numbers[i];
-        }
+        for(unsigned int j=i+1;j<len;j++)
+          {
+          unsigned int v2 = numbers[j];
+          if(v1==v2)
+            {
+            return v1;
+            }
+          }
+      }
     }
-
+  return 0;
-    return 0;
 }
 
-

numbers.h

@@ -1,8 +1,6 @@
 #ifndef NUMBERS_H
 #define NUMBERS_H
 
-
-int compareFct(const void *a, const void *b);
 // Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries.
 // Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
 // creating random numbers.

stack.c

@@ -10,11 +10,7 @@
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data)
 {
-  if (!data)
+    if(stack && data){
-  {
-    return stack; //Nichts pushen
-  }
-    //if(stack && data){
       StackNode *t = (StackNode *)malloc(sizeof(StackNode));
       if(!t)
         {
@@ -23,7 +19,7 @@ StackNode *push(StackNode *stack, void *data)
       t->next = stack;
       t->data = data;
       return t; //Gibt den ersten StackNode des Stacks zurueck
-      //}
+      }
     return NULL;
 }
 
@@ -31,11 +27,12 @@ StackNode *push(StackNode *stack, void *data)
 // freed by caller.)
 StackNode *pop(StackNode *stack)
 {
-    if(stack == NULL)
+    if(stack)
       {
-        return NULL;
+          StackNode *t = stack->next; //Naechstes Element im Stack wird erstes Element
+          free(stack);
+          return t;
       }
-    return stack->next;
 }
 
 // Returns the data of the top element.
@@ -53,8 +50,8 @@ void clearStack(StackNode *stack)
 {
   while(stack)
   {
-      StackNode *tmp = stack; //merkt sich den momentanen obersten Knoten
+      StackNode *tmp = stack;
-      stack = stack->next; //setzt den obersten Knoten auf den Zweiten im Stack
+      stack = stack->next;
       free(tmp->data);
       free(tmp);
   }

test_stack.c

@@ -1,72 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include "stack.h"
-
-//Testfunkionen zu push, pull, top & clearStack schreiben
-
-void setUp()
-  {
-  }
-
-void tearDown()
-      {
-  }
-
-void test(char *name, int condition) {
-    if (condition) {
-        printf("[OK]   %s\n", name);
-    } else {
-        printf("[FAIL] %s\n", name);
-    }
-}
-
-int main() {
-
-    StackNode *stack = NULL;
-
-    // Werte dynamisch anlegen
-    int *val1 = malloc(sizeof(int));
-    *val1 = 5;
-    stack = push(stack, val1);
-    test("push(5) legt 5 oben auf den Stack", *(int*)stack->data == 5);
-
-    int *val2 = malloc(sizeof(int));
-    *val2 = 6;
-    stack = push(stack, val2);
-    test("push(6) legt 6 oben auf den Stack", *(int*)stack->data == 6);
-
-    int *val3 = malloc(sizeof(int));
-    *val3 = 24;
-    stack = push(stack, val3);
-    test("push(24) legt 24 oben auf den Stack", *(int*)stack->data == 24);
-
-    // Test top()
-    int t = *(int*)top(stack);
-    test("top() liefert 24", t == 24);
-
-    // Test pop()
-    StackNode *tmp;
-    
-    tmp = stack;
-    stack = pop(stack);
-    free(tmp->data); // Daten freigeben
-    free(tmp);       // Knoten freigeben
-    test("pop() entfernt 24, 6 ist jetzt oben", *(int*)stack->data == 6);
-
-    tmp = stack;
-    stack = pop(stack);
-    free(tmp->data);
-    free(tmp);
-    test("pop() entfernt 6, 5 ist jetzt oben", *(int*)stack->data == 5);
-
-    tmp = stack;
-    stack = pop(stack);
-    free(tmp->data);
-    free(tmp);
-    test("pop() entfernt 5, Stack ist jetzt leer", stack == NULL);
-
-    // Am Ende Stack leeren (falls noch Elemente übrig)
-    clearStack(stack);
-
-    return 0;
-}