resolving conflicts

.gitignore

@@ -0,0 +1,22 @@
+# ===== Build =====
+cmake-build-*/
+build/
+out/
+
+# ===== IDE =====
+.idea/
+*.iml
+
+# ===== OS =====
+.DS_Store
+
+# ===== Compiled =====
+*.o
+*.obj
+*.a
+*.so
+*.dylib
+*.exe
+
+# ===== Logs =====
+*.log

CMakeLists.txt

@@ -8,28 +8,56 @@ 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
-        ${CMAKE_CURRENT_LIST_DIR}/main.cpp
-        ${CMAKE_CURRENT_LIST_DIR}/gamecube.cpp
+        src/main.cpp
+        src/gamecube.cpp
+        src/gamematrix.cpp
 )
 
 set(INCLUDE_DIRS
-        ${CMAKE_CURRENT_LIST_DIR}/linux
+        ${CMAKE_CURRENT_LIST_DIR}/includes
 )
 
 add_executable(${EXECUTABLE_NAME} ${SRC_FILES})
-target_include_directories(${EXECUTABLE_NAME} PRIVATE ${INCLUDE_DIRS})
+#target_include_directories(${EXECUTABLE_NAME} PRIVATE ${INCLUDE_DIRS})
+target_include_directories(Prog3B PRIVATE
+        ${CMAKE_CURRENT_LIST_DIR}/includes
+        ${CMAKE_CURRENT_LIST_DIR}/raylib
+)
 target_link_libraries(${EXECUTABLE_NAME} PRIVATE
-        ${CMAKE_CURRENT_LIST_DIR}/linux/libgamematrix.a
-        ${CMAKE_CURRENT_LIST_DIR}/linux/libraylib.a
+        #${CMAKE_CURRENT_LIST_DIR}/windows/libgamematrix.a
+        ${CMAKE_CURRENT_LIST_DIR}/windows/libraylib.a
+        opengl32
+        gdi32
+        m
+        winmm
 )
 
 # Checks if OSX and links appropriate frameworks (Only required on MacOS)
 if (APPLE)
-    target_link_libraries(Prog3B "-framework IOKit")
-    target_link_libraries(Prog3B "-framework Cocoa")
-    target_link_libraries(Prog3B "-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
+        opengl32
+        gdi32
+        winmm
+)
+
+if (APPLE)
+        target_link_libraries(Prog3B PRIVATE "-framework IOKit")
+        target_link_libraries(Prog3B PRIVATE "-framework Cocoa")
+        target_link_libraries(Prog3B PRIVATE "-framework OpenGL")
+endif()
+

docs/requirements.txt

@@ -0,0 +1,20 @@
+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:
+

gamematrix.h

@@ -1,19 +0,0 @@
-#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

@@ -0,0 +1,23 @@
+#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

@@ -1,136 +0,0 @@
-#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/gamecube.cpp

@@ -1,6 +1,7 @@
+#include "raylib.h"
 #include "gamecube.h"
 
-gamecube::gamecube(const Vec3 &pos, Color col)
+gamecube::gamecube(const Vec3& pos, Color col)
     : position(pos), color(col) {}
 
 void gamecube::Update(float flipSpeed)
@@ -27,8 +28,8 @@ void gamecube::Update(float flipSpeed)
     }
 }
 
-void gamecube::FlipForward()   { flippingForward = true; }
-void gamecube::FlipBackward()  { flippingBackward = true; }
+void gamecube::FlipForward()  { flippingForward = true; }
+void gamecube::FlipBackward() { flippingBackward = true; }
 
 bool gamecube::IsFlipped() const { return flipped; }
 bool gamecube::IsMatched() const { return matched; }
@@ -38,29 +39,28 @@ void gamecube::Draw() const
 {
     rlPushMatrix();
 
-    // Matrizen für Rotation und Translation erzeugen
-    auto matrix_a = gameMatrix::translate({ position.x, position.y, position.z});
-    auto matrix_b = gameMatrix::rot3D(rotation, 'y');
+    auto matrix_a = Matrix3D::gameMatrix::translate(
+        { position.x, position.y, position.z }
+    );
+    auto matrix_b = Matrix3D::gameMatrix::rot3D(rotation, 'y');
+    auto model = Matrix3D::gameMatrix::matmul(matrix_a, matrix_b);
 
-    // Matrizen multiplizieren (Translation * Rotation)
-    auto model = gameMatrix::matmul(matrix_a, matrix_b);
-
-    // transform for raylib matrix
     float f[16];
     for (int i = 0; i < 4; i++)
         for (int j = 0; j < 4; j++)
             f[j * 4 + i] = model[i][j];
+
     rlMultMatrixf(f);
 
     if (rotation < 90.0f)
-        DrawCube({0,0,0}, 1,1,1, GRAY);
+        DrawCube({ 0, 0, 0 }, 1, 1, 1, GRAY);
     else
-        DrawCube({0,0,0}, 1,1,1, color);
+        DrawCube({ 0, 0, 0 }, 1, 1, 1, color);
 
-    DrawCubeWires({0,0,0}, 1,1,1, BLACK);
+    DrawCubeWires({ 0, 0, 0 }, 1, 1, 1, BLACK);
 
     rlPopMatrix();
 }
 
-Vec3 gamecube::GetPosition() const     { return position; }
-float gamecube::GetRotationY() const   { return rotation; }
+Vec3 gamecube::GetPosition() const { return position; }
+float gamecube::GetRotationY() const { return rotation; }

src/gamematrix.cpp

@@ -0,0 +1,96 @@
+//
+// 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];
+        result[1][3] = pos[1];
+        result[2][3] = pos[2];
+
+        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

@@ -0,0 +1,227 @@
+#include "gamecube.h"
+#include "raylib.h"
+#include <algorithm>
+#include <ctime>
+#include <vector>
+#include <cstdio>
+
+// -----------------------------------------------------------
+// 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 };
+
+    int count = pairs * 2;
+    int cols = (count > 6) ? 4 : 3;
+    int rows = (count > 6) ? 3 : 2;
+
+    std::vector<Vec3> positions;
+    int index = 0;
+    for (int r = 0; r < rows && index < count; ++r)
+    {
+        for (int c = 0; c < cols && index < count; ++c)
+        {
+            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]);
+    }
+
+    // Shuffle
+    for (int i = (int)colorPool.size() - 1; i > 0; --i)
+    {
+        int j = rand() % (i + 1);
+        std::swap(colorPool[i], colorPool[j]);
+    }
+
+    for (int i = 0; i < count; ++i)
+        cubes.emplace_back(positions[i], colorPool[i]);
+}
+
+int main()
+{
+    srand((unsigned)time(nullptr));
+
+    InitWindow(800, 600, "3D Memory Game");
+    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;
+
+    GameScreen currentScreen = MENU;
+
+    std::vector<gamecube> cubes;
+    gamecube* first  = nullptr;
+    gamecube* second = nullptr;
+
+    int selectedPairs = 3;
+    float flipSpeed = 180.0f; // Grad pro Sekunde
+
+    bool gameWon = false;
+    bool timerStarted = false;
+    double startTime = 0.0;
+    double endTime = 0.0;
+
+    while (!WindowShouldClose())
+    {
+        // ---------------- UPDATE ----------------
+        switch (currentScreen)
+        {
+            case MENU:
+            {
+                if (IsKeyPressed(KEY_THREE))
+                {
+                    selectedPairs = 3;
+                    SetupGame(cubes, selectedPairs);
+                    currentScreen = GAMEPLAY;
+                    gameWon = false;
+                    first = second = nullptr;
+                    timerStarted = false;
+                }
+                else if (IsKeyPressed(KEY_SIX))
+                {
+                    selectedPairs = 6;
+                    SetupGame(cubes, selectedPairs);
+                    currentScreen = GAMEPLAY;
+                    gameWon = false;
+                    first = second = nullptr;
+                    timerStarted = false;
+                }
+                break;
+            }
+
+            case GAMEPLAY:
+            {
+                if (!timerStarted)
+                {
+                    startTime = GetTime();
+                    timerStarted = true;
+                }
+
+                // Klick-Erkennung mit Ray
+                if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && second == nullptr)
+                {
+                    Ray ray = GetMouseRay(GetMousePosition(), camera);
+                    gamecube* hit = nullptr;
+                    float bestDist = 1e9f;
+
+                    for (auto& c : cubes)
+                    {
+                        if (c.IsMatched() || c.IsFlipped()) continue;
+
+                        Vec3 p = c.GetPosition();
+                        BoundingBox box;
+                        box.min = { p.x - 0.75f, p.y - 0.75f, p.z - 0.75f };
+                        box.max = { p.x + 0.75f, p.y + 0.75f, p.z + 0.75f };
+
+                        RayCollision col = GetRayCollisionBox(ray, box);
+                        if (col.hit && col.distance < bestDist)
+                        {
+                            bestDist = col.distance;
+                            hit = &c;
+                        }
+                    }
+
+                    if (hit)
+                    {
+                        if (!first)
+                        {
+                            first = hit;
+                            first->FlipForward();
+                        }
+                        else if (hit != first)
+                        {
+                            second = hit;
+                            second->FlipForward();
+                        }
+                    }
+                }
+
+                // Animation
+                for (auto& c : cubes)
+                    c.Update(flipSpeed);
+
+                // Matching
+                if (first && second && first->IsFlipped() && second->IsFlipped())
+                {
+                    if (first->GetColor().r == second->GetColor().r &&
+                        first->GetColor().g == second->GetColor().g &&
+                        first->GetColor().b == second->GetColor().b)
+                    {
+                        first->SetMatched(true);
+                        second->SetMatched(true);
+                    }
+                    else
+                    {
+                        first->FlipBackward();
+                        second->FlipBackward();
+                    }
+
+                    first = nullptr;
+                    second = nullptr;
+                }
+
+                if (!gameWon)
+                {
+                    gameWon = std::all_of(cubes.begin(), cubes.end(),
+                        [](const gamecube& c){ return c.IsMatched(); });
+                    if (gameWon)
+                        endTime = GetTime() - startTime;
+                }
+                break;
+            }
+        }
+
+        // ---------------- DRAW ----------------
+        BeginDrawing();
+        ClearBackground(RAYWHITE);
+
+        if (currentScreen == MENU)
+        {
+            DrawText("3D MEMORY SPIEL", 200, 80, 40, DARKGRAY);
+            DrawText("[3]  = 3 Paare", 200, 200, 24, BLUE);
+            DrawText("[6]  = 6 Paare", 200, 240, 24, BLUE);
+        }
+        else
+        {
+            BeginMode3D(camera);
+            for (auto& c : cubes) c.Draw();
+            EndMode3D();
+
+            if (gameWon)
+            {
+                char buf[64];
+                sprintf(buf, "Gewonnen in %.2f Sekunden", endTime);
+                DrawText(buf, 150, 260, 30, DARKGREEN);
+            }
+            else
+            {
+                char buf[64];
+                sprintf(buf, "Time: %.2f", GetTime() - startTime);
+                DrawText(buf, 10, 10, 20, DARKGRAY);
+            }
+        }
+
+        EndDrawing();
+    }
+
+    CloseWindow();
+    return 0;
+}

src/tests.cpp

@@ -0,0 +1,99 @@
+#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

@@ -0,0 +1,36 @@
+============================================================
+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.
+============================================================