ARCH: Design-Dokumentation final

.gitignore

@@ -1 +0,0 @@
-.idea/

.idea/.gitignore

@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

.idea/vcs.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings" defaultProject="true" />
-</project>

CMakeLists.txt

@@ -8,51 +8,28 @@ set(CMAKE_CXX_STANDARD 20)
 
 # Set the default build type if not specified
 if(NOT CMAKE_BUILD_TYPE)
-        set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
 endif()
 
 set(SRC_FILES
-        src/main.cpp
-        src/gamecube.cpp
-        src/gamematrix.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/main.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/gamecube.cpp
 )
 
 set(INCLUDE_DIRS
-        ${CMAKE_CURRENT_LIST_DIR}/includes
+        ${CMAKE_CURRENT_LIST_DIR}/linux
 )
 
 add_executable(${EXECUTABLE_NAME} ${SRC_FILES})
-#target_include_directories(${EXECUTABLE_NAME} PRIVATE ${INCLUDE_DIRS})
-target_include_directories(Prog3B PRIVATE
-        ${CMAKE_CURRENT_LIST_DIR}/includes
-        ${CMAKE_CURRENT_LIST_DIR}/raylib
-)
+target_include_directories(${EXECUTABLE_NAME} PRIVATE ${INCLUDE_DIRS})
 target_link_libraries(${EXECUTABLE_NAME} PRIVATE
-        #${CMAKE_CURRENT_LIST_DIR}/windows/libgamematrix.a
-        ${CMAKE_CURRENT_LIST_DIR}/mac_arm/libraylib.a
-
+        ${CMAKE_CURRENT_LIST_DIR}/linux/libgamematrix.a
+        ${CMAKE_CURRENT_LIST_DIR}/linux/libraylib.a
 )
 
 # Checks if OSX and links appropriate frameworks (Only required on MacOS)
 if (APPLE)
-        target_link_libraries(Prog3B PRIVATE "-framework IOKit"
-        "-framework Cocoa"
-         "-framework OpenGL"
-        )
+    target_link_libraries(Prog3B "-framework IOKit")
+    target_link_libraries(Prog3B "-framework Cocoa")
+    target_link_libraries(Prog3B "-framework OpenGL")
 endif()
-
-add_executable(tests
-        ${CMAKE_CURRENT_LIST_DIR}/src/tests.cpp
-        ${CMAKE_CURRENT_LIST_DIR}/src/gamematrix.cpp
-)
-target_include_directories(tests PRIVATE ${INCLUDE_DIRS})
-
-target_link_libraries(tests PRIVATE)
-
-#if (APPLE)
-        #target_link_libraries(Prog3B PRIVATE "-framework IOKit")
-        #target_link_libraries(Prog3B PRIVATE "-framework Cocoa")
-        #target_link_libraries(Prog3B PRIVATE "-framework OpenGL")
-
-#endif()
-

Prog3b_651

@@ -1 +0,0 @@
-Subproject commit 21700018752d7b19e3c2642707b1c1b06e2f3d84

design.txt

@@ -0,0 +1,75 @@
+
+Eine  Mücke
+
+
+========================================================
+Projekt: gamematrix (C++ Library)
+Rolle: Architekt
+Datei: design.txt
+Datum: 16.11.25
+Team:bhattial100541
+========================================================
+
+# ----------------------------
+# 1. Projektstruktur / Namespace
+# ----------------------------
+Namespace: Matrix3D
+
+Ziel: Saubere Trennung der Bibliothek, Vermeidung von Namenskonflikten.
+
+Beispiel:
+namespace Matrix3D {
+    // Funktionen, ggf Klasse(n)
+}
+
+# ----------------------------
+# 2. Datenstrukturen / Klassen
+# ----------------------------
+Listen Sie die Klassen oder Structs auf, die verwendet werden:
+
+Name	Typ	Beschreibung
+Vec3	struct Vec3 (z.B. std::array<double, 3>)	3D-Vektor (x, y, z)
+Mat4	std::array<std::array<double,4>,4>	4x4-Matrix (homogen)
+Vec4	struct Vec4 (z.B. std::array<double, 4>)	4D-Vektor (Homogene Koordinaten)
+gameMatrix	class gameMatrix (Container für statische Methoden)	Statische Klasse zur Erzeugung von Transformationsmatrizen
+# ----------------------------
+# 3. Operatoren / Templates
+# ----------------------------
+Welche Operatoren oder Templates sollen definiert werden?
+
+- Templates für unterschiedliche Datentypen? ☐  Nein
+- Operatoren:
+    - Mat4 * Mat4(Matrix-Matrix-Multiplikation)
+    - Mat4 * Vec3(Matrix-Vektor-Multiplikation unter Nutzung homogener Koordinaten)
+
+# ----------------------------
+# 4. Funktionen / Schnittstellen
+# ----------------------------
+Liste der Funktionen mit Eingabe/Ausgabe und kurzer Beschreibung:
+
+Funktion	Eingabe	Ausgabe	Kurzbeschreibung
+matmul	const Mat4& A, const Mat4& B	Mat4	Matrixmultiplikation 4x4
+translate	const Vec3& pos	Mat4	Erzeugt eine Verschiebungstransformationsmatrix
+rot3D	double angle_deg, char axis ('x', 'y', 'z')	Mat4	Erzeugt eine Rotationsmatrix um Achse x/y/z
+identity	---	Mat4	Erzeugt die 4x4-Identitätsmatrix
+operator*	const Mat4& m, const Vec3& v	Vec3	Multipliziert Matrizen mit 3D-Vektoren (Homogen-Adapter)
+
+# ----------------------------
+# 5. Designentscheidungen / Hinweise
+# ----------------------------
+- Rückgabe der Matrizen per Wert oder Referenz? Wert(Transformationsmatrizen, da diese neu erzeugt werden und Copy Elision durch moderne Compiler optimiert werden kann)
+- Verwendung von std::array oder std::vector? std::array(bessere Performance und speichereffizienter als std::vector)
+- Homogene Koordinaten für Translation / Rotation (4x4)? ☐ Ja
+- Weitere Designüberlegungen: Klasse gameMatrix dient als Utility Class, sollte keine eigene zustände besitzen, daher Funktionen sind static implementiert, folgt den OCP principle
+
+# ----------------------------
+# 6. Deliverables / Milestones
+# ----------------------------
+- design.txt fertig und im Branch architect committed
+- Übergabe an Entwickler für Implementierung
+
+========================================================
+Hinweis:
+- Dieses Dokument dient als Grundlage für die Implementierung.
+- Alle Designentscheidungen sollen klar nachvollziehbar sein.
+========================================================

docs/requirements.txt

@@ -1,20 +0,0 @@
-Projekt: .wuerfelmemory
-Datum: 03.11.2025
-
-
-Team(Rollen):Projektleiter: Alina.B
-            Architekt:     Alex.S
-            Entwickler:    Tomila.B
-            Tester:        Elisa.S
-
-1.Projektziel:
-
-| Funktion      | Eingabe                            | Ausgabe               | Kurzbeschreibung                       |
-|---------------|------------------------------------|-----------------------|----------------------------------------|
-| matmul        | 4x4 Matrix A, 4x4 Matrix B         | 4x4 Matrix            |                                        |
-| translate     | 3D Vektor                          | 4x4 Matrix            |                                        |
-| rot3D         | Winkel in °, Rotationsachse (x/y/z)| 4x4 Matrix            |                                        |
-
-
-Dokumentation:
-

gamecube.cpp

@@ -39,11 +39,11 @@ void gamecube::Draw() const
     rlPushMatrix();
 
     // Matrizen für Rotation und Translation erzeugen
-    auto matrix_a = Matrix3D::gameMatrix::translate({ position.x, position.y, position.z});
-    auto matrix_b = Matrix3D::gameMatrix::rot3D(rotation, 'y');
+    auto matrix_a = gameMatrix::translate({ position.x, position.y, position.z});
+    auto matrix_b = gameMatrix::rot3D(rotation, 'y');
 
     // Matrizen multiplizieren (Translation * Rotation)
-    auto model = Matrix3D::gameMatrix::matmul(matrix_a, matrix_b);
+    auto model = gameMatrix::matmul(matrix_a, matrix_b);
 
     // transform for raylib matrix
     float f[16];

gamematrix.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <vector>
+#include <array>
+#include <stdexcept>
+#include <cmath>
+
+class gameMatrix
+{
+public:
+    // Matrix Multiplikation
+    static std::array<std::array<double,4>,4> matmul(const std::array<std::array<double,4>,4>& A,
+                                                   const std::array<std::array<double,4>,4>& B);
+
+    // Rotationsmatrix um Achse x/y/z
+    static std::array<std::array<double,4>,4> rot3D(double angle_deg, char axis);
+
+    // Verschiebung
+    static std::array<std::array<double,4>,4> translate(const std::array<double, 3>& pos);
+};

includes/gamematrix.h

@@ -1,23 +0,0 @@
-#pragma once
-#include <vector>
-#include <array>
-#include <stdexcept>
-#include <cmath>
-
-namespace Matrix3D
-{
-    using Vec3 = std::array<double, 3>;
-    using Vec4 = std::array<double, 4>;
-    using Mat4 = std::array<std::array<double, 4>, 4>;
-
-    class gameMatrix
-    {
-    public:
-        static Mat4 identity();
-        static Mat4 matmul(const Mat4& A, const Mat4& B);
-        static Mat4 translate(const Vec3& pos);
-        static Mat4 rot3D(double angle_deg, char axis);
-    };
-    Mat4 operator*(const Mat4& A, const Mat4& B);
-    Vec3 operator*(const Mat4& m, const Vec3& v);
-}

main.cpp

@@ -0,0 +1,136 @@
+#include "gamecube.h"
+#include <algorithm>
+#include <ctime>
+
+// -----------------------------------------------------------
+// 3D Memory Game – Hauptprogramm
+// -----------------------------------------------------------
+int main()
+{
+    // Zufall initialisieren
+    srand(time(NULL));
+
+    // Fenster und Kamera
+    InitWindow(800, 600, "3D Memory Game with Matrix3D Library");
+    SetTargetFPS(60);
+
+    Camera3D camera{};
+    camera.position = {6.0f, 6.0f, 6.0f};
+    camera.target   = {0.0f, 0.0f, 0.0f};
+    camera.up       = {0.0f, 1.0f, 0.0f};
+    camera.fovy     = 45.0f;
+    camera.projection = CAMERA_PERSPECTIVE;
+
+    // Nur 3 Farben für 3 Paare
+    Color colors[] = { RED, GREEN, BLUE };
+
+    // 6 Karten-Positionen im 3x2 Raster
+    std::vector<Vec3> positions = {{-2, 0, -2}, {0, 0, -2}, {2, 0, -2},{-2, 0,  0}, {0, 0,  0}, {2, 0,  0}};
+
+    // Farben doppelt in einen Pool legen und mischen
+    std::vector<Color> colorPool;
+    for (int i = 0; i < 3; i++)
+    {
+        colorPool.push_back(colors[i]);
+        colorPool.push_back(colors[i]);
+    }
+
+    // Fisher-Yates Shuffle mit rand()
+    for (int i = colorPool.size() - 1; i > 0; --i)
+    {
+        int j = rand() % (i + 1);   // Zufallsindex von 0 bis i
+        std::swap(colorPool[i], colorPool[j]);
+    }
+
+    // Karten/Würfel erstellen
+    std::vector<gamecube> cubes;
+    for (int i = 0; i < 6; i++)
+        cubes.emplace_back(positions[i], colorPool[i]);
+
+    gamecube* first  = nullptr;
+    gamecube* second = nullptr;
+    float flipSpeed = 5.0f;  // Drehgeschwindigkeit
+    bool gameWon = false;
+
+    // -----------------------------------------------------------
+    // Hauptspielschleife
+    // -----------------------------------------------------------
+    while (!WindowShouldClose())
+    {
+        // Klick-Erkennung
+        if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+        {
+            Vector2 mouse = GetMousePosition();
+
+            for (auto &c : cubes)
+            {
+                if (!c.IsFlipped() && !c.IsMatched())
+                {
+                    Vector2 screenPos = GetWorldToScreen({c.GetPosition().x, c.GetPosition().y, c.GetPosition().z}, camera);
+
+                    if (fabs(mouse.x - screenPos.x) < 40 && fabs(mouse.y - screenPos.y) < 40)
+                        c.FlipForward();
+                }
+            }
+        }
+
+        // Animation aller Würfel
+        for (auto &c : cubes)
+        {
+            c.Update(flipSpeed);
+
+            // Sobald ein Würfel vollständig umgedreht ist → merken
+            if (c.IsFlipped() && !c.IsMatched())
+            {
+                if (!first) first = &c;
+                else if (!second && &c != first) second = &c;
+            }
+        }
+
+        // Matching-Logik
+        if (first && second)
+        {
+            Color col1 = first->GetColor();
+            Color col2 = second->GetColor();
+
+            if (col1.r == col2.r && col1.g == col2.g && col1.b == col2.b)
+            {
+                first->SetMatched(true);
+                second->SetMatched(true);
+            }
+            else
+            {
+                first->FlipBackward();
+                second->FlipBackward();
+            }
+
+            first = second = nullptr;
+        }
+
+        // Gewinnprüfung
+        if (!gameWon)
+            gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
+
+        // -----------------------------------------------------------
+        // Zeichnen
+        // -----------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(RAYWHITE);
+        BeginMode3D(camera);
+
+        for (auto &c : cubes)
+            c.Draw();
+
+        EndMode3D();
+
+        if (gameWon)
+            DrawText("Congrats! You found all pairs!", 150, 260, 30, DARKBLUE);
+        else
+            DrawText("Flip 2 cubes - find matching pairs!", 10, 10, 20, DARKGRAY);
+
+        EndDrawing();
+    }
+
+    CloseWindow();
+    return 0;
+}

src/gamematrix.cpp

@@ -1,97 +0,0 @@
-//
-// Created by bakee on 03.11.2025.
-//
-#include "gamematrix.h"
-#include <cmath>
-
-namespace Matrix3D
-{
-    Mat4 gameMatrix::identity()
-    {
-        return {{
-            {1.0, 0.0, 0.0, 0.0},
-            {0.0, 1.0, 0.0, 0.0},
-            {0.0, 0.0, 1.0, 0.0},
-            {0.0, 0.0, 0.0, 1.0}
-        }};
-    }
-
-    Mat4 gameMatrix::matmul(const Mat4& A, const Mat4& B)
-    {
-        const int N = 4;
-        Mat4 result = {};
-        for (int i = 0; i < N; ++i)
-        {
-            for (int j = 0; j < N; ++j)
-            {
-                for (int k = 0; k < N; ++k)
-                {
-                    result[i][j] += A[i][k] * B[k][j];
-                }
-            }
-        }
-        return result;
-    }
-
-    Mat4 gameMatrix::translate(const Vec3& pos)
-    {
-        Mat4 result = identity();
-
-        result[0][3] = pos[0]; // x
-        result[1][3] = pos[1]; // y
-        result[2][3] = pos[2]; // z
-
-        return result;
-    }
-
-    Mat4 gameMatrix::rot3D(double angle_deg, char axis)
-    {
-        const double angle_rad = angle_deg * M_PI / 180.0;
-
-        Mat4 result = identity();
-
-        const double c = std::cos(angle_rad);
-        const double s = std::sin(angle_rad);
-
-        switch (axis)
-        {
-            case 'x':
-                result[1][1] = c; result[1][2] = -s;
-                result[2][1] = s; result[2][2] = c;
-                break;
-            case 'y':
-                result[0][0] = c; result[0][2] = s;
-                result[2][0] = -s; result[2][2] = c;
-                break;
-            case 'z':
-                result[0][0] = c; result[0][1] = -s;
-                result[1][0] = s; result[1][1] = c;
-                break;
-            default:
-                break;
-        }
-        return result;
-    }
-
-    Mat4 operator*(const Mat4& A, const Mat4& B)
-    {
-        return gameMatrix::matmul(A, B);
-    }
-
-    Vec3 operator*(const Mat4& m, const Vec3& v)
-    {
-        Vec4 v_hom = {v[0], v[1], v[2], 1.0};
-        Vec4 res_hom = {};
-
-        for (int i = 0; i < 4; ++i)
-        {
-            for (int j = 0; j < 4; ++j)
-            {
-                res_hom[i] += m[i][j] * v_hom[j];
-            }
-        }
-
-        return {res_hom[0], res_hom[1], res_hom[2]};
-    }
-
-}

src/main.cpp

@@ -1,370 +0,0 @@
-#include "gamecube.h"
-#include <algorithm>
-#include <ctime>
-#include <vector>
-#include "raylib.h" // Stellen Sie sicher, dass raylib.h hier oder in gamecube.h inkludiert ist
-
-
-// -----------------------------------------------------------
-// 3D Memory Game – Hauptprogramm
-// -----------------------------------------------------------
-
-enum GameScreen {MENU = 0, GAMEPLAY};
-
-
-void SetupGame(std::vector<gamecube>& cubes, int pairs)
-{
-    cubes.clear();
-    Color colors[] = {RED, GREEN, BLUE, YELLOW, ORANGE, PURPLE, WHITE, SKYBLUE};
-    std::vector<Vec3> positions;
-
-    int count = pairs * 2;
-    int cols = 3;
-    int rows = 2;
-    if (count > 6) {
-        cols = 4;
-        rows = 3;
-    }
-    int index = 0;
-    // Generiert Positionen basierend auf der Größe
-    for (int r = 0; r < rows && index < count; ++r) {
-        for (int c = 0; c < cols && index < count; ++c) {
-            // Zentriert die Würfel um (0,0,0)
-            positions.push_back({(float)c * 2.0f - (cols -1 ), 0.0f, (float)r * 2.0f - (rows -1)});
-            index++;
-        }
-    }
-
-    std::vector<Color> colorPool;
-    for (int i = 0; i < pairs; i++) {
-        colorPool.push_back(colors[i]);
-        colorPool.push_back(colors[i]);
-    }
-
-    // Fisher-Yates Shuffle
-    for (int i= colorPool.size() -1; i > 0; --i) {
-        int j = rand() % (i + 1);
-        std::swap(colorPool[i], colorPool[j]);
-    }
-
-    // Würfel erstellen
-    for (int i = 0; i < count; i++)
-        cubes.emplace_back(positions[i], colorPool[i]);
-
-}
-
-int main()
-{
-    // Zufall initialisieren#include "gamecube.h"
-    //#include <algorithm>
-    //#include <ctime>
-    //
-    //// -----------------------------------------------------------
-    //// 3D Memory Game – Hauptprogramm
-    //// -----------------------------------------------------------
-    //int main()
-    //{
-    //    // Zufall initialisieren
-    //    srand(time(NULL));
-    //
-    //    // Fenster und Kamera
-    //    InitWindow(800, 600, "3D Memory Game with Matrix3D Library");
-    //    SetTargetFPS(60);
-    //
-    //    Camera3D camera{};
-    //    camera.position = {6.0f, 6.0f, 6.0f};
-    //    camera.target   = {0.0f, 0.0f, 0.0f};
-    //    camera.up       = {0.0f, 1.0f, 0.0f};
-    //    camera.fovy     = 45.0f;
-    //    camera.projection = CAMERA_PERSPECTIVE;
-    //
-    //    // Nur 3 Farben für 3 Paare
-    //    Color colors[] = { RED, GREEN, BLUE };
-    //
-    //    // 6 Karten-Positionen im 3x2 Raster
-    //    std::vector<Vec3> positions = {{-2, 0, -2}, {0, 0, -2}, {2, 0, -2},{-2, 0,  0}, {0, 0,  0}, {2, 0,  0}};
-    //
-    //    // Farben doppelt in einen Pool legen und mischen
-    //    std::vector<Color> colorPool;
-    //    for (int i = 0; i < 3; i++)
-    //    {
-    //        colorPool.push_back(colors[i]);
-    //        colorPool.push_back(colors[i]);
-    //    }
-    //
-    //    // Fisher-Yates Shuffle mit rand()
-    //    for (int i = colorPool.size() - 1; i > 0; --i)
-    //    {
-    //        int j = rand() % (i + 1);   // Zufallsindex von 0 bis i
-    //        std::swap(colorPool[i], colorPool[j]);
-    //    }
-    //
-    //    // Karten/Würfel erstellen
-    //    std::vector<gamecube> cubes;
-    //    for (int i = 0; i < 6; i++)
-    //        cubes.emplace_back(positions[i], colorPool[i]);
-    //
-    //    gamecube* first  = nullptr;
-    //    gamecube* second = nullptr;
-    //    float flipSpeed = 5.0f;  // Drehgeschwindigkeit
-    //    bool gameWon = false;
-    //
-    //    // -----------------------------------------------------------
-    //    // Hauptspielschleife
-    //    // -----------------------------------------------------------
-    //    while (!WindowShouldClose())
-    //    {
-    //        // Klick-Erkennung
-    //        if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
-    //        {
-    //            Vector2 mouse = GetMousePosition();
-    //
-    //            for (auto &c : cubes)
-    //            {
-    //                if (!c.IsFlipped() && !c.IsMatched())
-    //                {
-    //                    Vector2 screenPos = GetWorldToScreen({c.GetPosition().x, c.GetPosition().y, c.GetPosition().z}, camera);
-    //
-    //                    if (fabs(mouse.x - screenPos.x) < 40 && fabs(mouse.y - screenPos.y) < 40)
-    //                        c.FlipForward();
-    //                }
-    //            }
-    //        }
-    //
-    //        // Animation aller Würfel
-    //        for (auto &c : cubes)
-    //        {
-    //            c.Update(flipSpeed);
-    //
-    //            // Sobald ein Würfel vollständig umgedreht ist → merken
-    //            if (c.IsFlipped() && !c.IsMatched())
-    //            {
-    //                if (!first) first = &c;
-    //                else if (!second && &c != first) second = &c;
-    //            }
-    //        }
-    //
-    //        // Matching-Logik
-    //        if (first && second)
-    //        {
-    //            Color col1 = first->GetColor();
-    //            Color col2 = second->GetColor();
-    //
-    //            if (col1.r == col2.r && col1.g == col2.g && col1.b == col2.b)
-    //            {
-    //                first->SetMatched(true);
-    //                second->SetMatched(true);
-    //            }
-    //            else
-    //            {
-    //                first->FlipBackward();
-    //                second->FlipBackward();
-    //            }
-    //
-    //            first = second = nullptr;
-    //        }
-    //
-    //        // Gewinnprüfung
-    //        if (!gameWon)
-    //            gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
-    //
-    //        // -----------------------------------------------------------
-    //        // Zeichnen
-    //        // -----------------------------------------------------------
-    //        BeginDrawing();
-    //        ClearBackground(RAYWHITE);
-    //        BeginMode3D(camera);
-    //
-    //        for (auto &c : cubes)
-    //            c.Draw();
-    //
-    //        EndMode3D();
-    //
-    //        if (gameWon)
-    //            DrawText("Congrats! You found all pairs!", 150, 260, 30, DARKBLUE);
-    //        else
-    //            DrawText("Flip 2 cubes - find matching pairs!", 10, 10, 20, DARKGRAY);
-    //
-    //        EndDrawing();
-    //    }
-    //
-    //    CloseWindow();
-    //    return 0;
-    //}
-    srand(time(NULL));
-    double startTime = 0.0;
-    double endTime = 0.0;
-    bool timerStarted = false;
-
-    GameScreen currentScreen = MENU;
-    int selectedPairs = 3;
-
-    // 1. SPIELSPEZIFISCHE VARIABLEN HIER DEKLARIEREN (ohne Initialisierung)
-    std::vector<gamecube> cubes;
-    gamecube* first  = nullptr;
-    gamecube* second = nullptr;
-    float flipSpeed = 5.0f;  // Drehgeschwindigkeit
-    bool gameWon = false;
-
-    // Fenster und Kamera
-    InitWindow(800, 600, "3D Memory Game with Matrix3D Library");
-    SetTargetFPS(60);
-
-    Camera3D camera{};
-    camera.position = {6.0f, 6.0f, 6.0f};
-    camera.target   = {0.0f, 0.0f, 0.0f};
-    camera.up       = {0.0f, 1.0f, 0.0f};
-    camera.fovy     = 45.0f;
-    camera.projection = CAMERA_PERSPECTIVE;
-
-    // -----------------------------------------------------------
-    // Hauptspielschleife
-    // -----------------------------------------------------------
-    while (!WindowShouldClose())
-    {
-        // -------------------------------------------------------
-        // UPDATE-LOGIK NACH ZUSTAND
-        // -------------------------------------------------------
-        switch (currentScreen)
-        {
-            case MENU:
-            {
-                // Menü-Abfrage: Auf Tastendruck warten
-                if (IsKeyPressed(KEY_THREE)) {
-                    selectedPairs = 3; // 6 Würfel
-                    SetupGame(cubes, selectedPairs);
-                    gameWon = false;
-                    first = second = nullptr;
-                    currentScreen = GAMEPLAY;
-                    timerStarted = false; // Timer-Reset
-                } else if (IsKeyPressed(KEY_SIX)) {
-                    selectedPairs = 6; // 12 Würfel
-                    SetupGame(cubes, selectedPairs);
-                    gameWon = false;
-                    first = second = nullptr;
-                    currentScreen = GAMEPLAY;
-                    timerStarted = false; // Timer-Reset
-                }
-                break;
-            }
-
-            case GAMEPLAY:
-            {
-                // Timer starten
-                if (!timerStarted)
-                {
-                    startTime = GetTime();
-                    timerStarted = true;
-                }
-
-                // Klick-Erkennung
-                if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
-                {
-                    Vector2 mouse = GetMousePosition();
-                    for (auto &c : cubes)
-                    {
-                        if (!c.IsFlipped() && !c.IsMatched())
-                        {
-                            Vector2 screenPos = GetWorldToScreen({c.GetPosition().x, c.GetPosition().y, c.GetPosition().z}, camera);
-                            if (fabs(mouse.x - screenPos.x) < 40 && fabs(mouse.y - screenPos.y) < 40)
-                                c.FlipForward();
-                        }
-                    }
-                }
-
-                // Animation aller Würfel
-                for (auto &c : cubes)
-                {
-                    c.Update(flipSpeed);
-                    if (c.IsFlipped() && !c.IsMatched())
-                    {
-                        if (!first) first = &c;
-                        else if (!second && &c != first) second = &c;
-                    }
-                }
-
-                // Matching-Logik
-                if (first && second)
-                {
-                    Color col1 = first->GetColor();
-                    Color col2 = second->GetColor();
-
-                    if (col1.r == col2.r && col1.g == col2.g && col1.b == col2.b)
-                    {
-                        first->SetMatched(true);
-                        second->SetMatched(true);
-                    }
-                    else
-                    {
-                        first->FlipBackward();
-                        second->FlipBackward();
-                    }
-                    first = second = nullptr;
-                }
-
-                // Gewinnprüfung
-                if (!gameWon)
-                {
-                    // Prüft, ob ALLE Würfel gematcht sind
-                    gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
-                    if (gameWon)
-                    {
-                        endTime = GetTime() - startTime;
-                    }
-                }
-                break;
-            } // ENDE GAMEPLAY UPDATE
-        }
-
-        // -----------------------------------------------------------
-        // ZEICHNEN NACH ZUSTAND
-        // -----------------------------------------------------------
-        BeginDrawing();
-        ClearBackground(RAYWHITE);
-
-        switch (currentScreen)
-        {
-            case MENU:
-            {
-                // Menü-Darstellung
-                DrawText("3D MEMORY SPIEL", GetScreenWidth() / 2 - MeasureText("3D MEMORY SPIEL", 50) / 2, 80, 50, DARKGRAY);
-                DrawText("Waehlen Sie die Spielgroesse:", 50, 200, 25, BLACK);
-                DrawText("Druecken Sie [3] fuer 3 Paare (6 Wuerfel)", 50, 240, 20, BLUE);
-                DrawText("Druecken Sie [6] fuer 6 Paare (12 Wuerfel)", 50, 280, 20, BLUE);
-                break;
-            }
-
-            case GAMEPLAY:
-            {
-                // Spiel-Darstellung
-                BeginMode3D(camera);
-
-                for (auto &c : cubes)
-                    c.Draw();
-
-                EndMode3D();
-
-                if (gameWon)
-                {
-                    DrawText("Congrats! You found all pairs!", 150, 260, 30, DARKBLUE);
-                    char buffer[64];
-                    sprintf(buffer, "Cleared in %.2f seconds", endTime);
-                    DrawText(buffer, 150, 300, 28, DARKGREEN);
-                }
-                else
-                {
-                    DrawText("Flip 2 cubes - find matching pairs!", 10, 10, 20, DARKGRAY);
-                    char liveBuf[64];
-                    sprintf(liveBuf, "Time: %.2f", GetTime() - startTime);
-                    DrawText(liveBuf, 10, 40, 20, DARKGRAY);
-                }
-                break;
-            } // ENDE GAMEPLAY DRAW
-        }
-
-        EndDrawing();
-    }
-
-    CloseWindow();
-    return 0;
-}

src/tests.cpp

@@ -1,99 +0,0 @@
-#include <iostream>
-#include <array>
-#include <cmath>
-#include "gamematrix.h"
-
-using Matrix4 = std::array<std::array<double,4>,4>;
-using Vec3    = std::array<double,3>;
-
-bool eq(double a, double b) {
-    return std::fabs(a - b) < 0.0001;
-}
-
-Matrix4 identity() {
-    Matrix4 I{};
-    for (int i = 0; i < 4; i++) {
-        I[i][i] = 1.0;
-    }
-    return I;
-}
-
-Vec3 applyMatrix(const Matrix4& M, const Vec3& v) {
-    Vec3 r{0,0,0};
-
-    r[0] = M[0][0]*v[0] + M[0][1]*v[1] + M[0][2]*v[2] + M[0][3];
-    r[1] = M[1][0]*v[0] + M[1][1]*v[1] + M[1][2]*v[2] + M[1][3];
-    r[2] = M[2][0]*v[0] + M[2][1]*v[1] + M[2][2]*v[2] + M[2][3];
-
-    return r;
-}
-
-void testMatmulIdentity() {
-    Matrix4 A = identity();
-    Matrix4 B = identity();
-    Matrix4 C = Matrix3D::gameMatrix::matmul(A, B);
-
-    for (int i = 0; i < 4; i++) {
-        for (int j = 0; j < 4; j++) {
-            double expected = (i == j ? 1.0 : 0.0);
-            if (!eq(C[i][j], expected)) {
-                std::cout << "[FAIL] matmul Identity\n";
-                return;
-            }
-        }
-    }
-
-    std::cout << "[OK] matmul Identity\n";
-}
-
-void testTranslate() {
-    Vec3 pos{1,2,3};
-    Matrix4 T = Matrix3D::gameMatrix::translate(pos);
-
-    if (eq(T[0][3], 1) && eq(T[1][3], 2) && eq(T[2][3], 3))
-        std::cout << "[OK] translate\n";
-    else
-        std::cout << "[FAIL] translate\n";
-}
-
-void testRotZ90() {
-    Vec3 v{1,0,0};
-    Matrix4 R = Matrix3D::gameMatrix::rot3D(90, 'z');
-    Vec3 r = applyMatrix(R, v);
-
-    if (eq(r[0], 0) && eq(r[1], 1) && eq(r[2], 0))
-        std::cout << "[OK] rotZ 90°\n";
-    else
-        std::cout << "[FAIL] rotZ 90°\n";
-}
-
-void testRotX180() {
-    Vec3 v{0,1,0};
-    Matrix4 R = Matrix3D::gameMatrix::rot3D(180, 'x');
-    Vec3 r = applyMatrix(R, v);
-
-    if (eq(r[0], 0) && eq(r[1], -1) && eq(r[2], 0))
-        std::cout << "[OK] rotX 180°\n";
-    else
-        std::cout << "[FAIL] rotX 180°\n";
-}
-
-void testRotY270() {
-    Vec3 v{1,0,0};
-    Matrix4 R = Matrix3D::gameMatrix::rot3D(270, 'y');
-    Vec3 r = applyMatrix(R, v);
-
-    if (eq(r[0], 0) && eq(r[1], 0) && eq(r[2], 1))
-        std::cout << "[OK] rotY 270°\n";
-    else
-        std::cout << "[FAIL] rotY 270°\n";
-}
-
-int main() {
-    testMatmulIdentity();
-    testTranslate();
-    testRotZ90();
-    testRotX180();
-    testRotY270();
-    return 0;
-}

tests.txt

@@ -1,36 +0,0 @@
-============================================================
-Projekt: gamematrix (C++ Library)
-Rolle: Tester
-Datei: tests.txt
-============================================================
-
-# 1. Testplan Übersicht
-
-Ziel: Überprüfung der Funktionen matmul(), translate(), rot3D().
-
----------------------------------------------------------------------------------------------------------------
-| Funktion | Testfall              | Eingabe                                      | Erwartetes Ergebnis       | Bemerkung                       |
-|---------|------------------------|----------------------------------------------|---------------------------|---------------------------------|
-| matmul  | Identity * Identity    | 4x4 Identity Matrizen                        | Identity                  | Basisfall                       |
-| translate | Verschiebung        | Vec3(1,2,3)                                  | Matrix mit Translation    | Letzte Spalte prüfen            |
-| rot3D   | Rotation Z 90°         | angle=90, axis='z', v=(1,0,0)                | (0,1,0)                   | Anwendung auf Vektor            |
-| rot3D   | Rotation X 180°        | angle=180, axis='x', v=(0,1,0)               | (0,-1,0)                  | Anwendung auf Vektor            |
-| rot3D   | Rotation Y 270°        | angle=270, axis='y', v=(1,0,0)               | (0,0,-1)                  | Anwendung auf Vektor            |
----------------------------------------------------------------------------------------------------------------
-
-# 2. Testdaten
-
-- Matrizen für matmul: zwei Identity-Matrizen
-- Vektoren für translate: Vec3(1,2,3)
-- Vektoren für rot3D: (1,0,0), (0,1,0)
-
-# 3. Abnahmekriterien
-
-- Alle Testfälle laufen ohne Fehler durch.
-- Ergebnisse stimmen mit erwarteten Ergebnissen überein.
-- Keine unerwarteten Exceptions.
-- Tester dokumentiert Erfolg oder Fehler im Terminal.
-
-============================================================
-Hinweis: Datei wird vom Tester gepflegt.
-============================================================