.gitignore

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

.idea/.gitignore

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

.idea/vcs.xml

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

.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        
+
+    ]
+}

CMakeLists.txt

@@ -17,9 +17,9 @@ set(SRC_FILES
         src/gamematrix.cpp
 )
 
-set(INCLUDE_DIRS
-        ${CMAKE_CURRENT_LIST_DIR}/includes
-)
+#set(INCLUDE_DIRS
+#        ${CMAKE_CURRENT_LIST_DIR}/linux
+#)
 
 add_executable(${EXECUTABLE_NAME} ${SRC_FILES})
 #target_include_directories(${EXECUTABLE_NAME} PRIVATE ${INCLUDE_DIRS})
@@ -42,22 +42,3 @@ if (APPLE)
     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()
-

src/gamecube.cpp

@@ -1,4 +1,3 @@
-#include "raylib.h"
 #include "gamecube.h"
 
 gamecube::gamecube(const Vec3 &pos, Color col)
@@ -39,17 +38,18 @@ void gamecube::Draw() const
 {
     rlPushMatrix();
 
-    auto matrix_a = Matrix3D::gameMatrix::translate(
-        { position.x, position.y, position.z }
-    );
+    // 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');
+
+    // Matrizen multiplizieren (Translation * Rotation)
     auto model = Matrix3D::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)

src/gamematrix.cpp

@@ -37,9 +37,9 @@ namespace Matrix3D
     {
         Mat4 result = identity();
 
-        result[0][3] = pos[0];
-        result[1][3] = pos[1];
-        result[2][3] = pos[2];
+        result[0][3] = pos[0]; // x
+        result[1][3] = pos[1]; // y
+        result[2][3] = pos[2]; // z
 
         return result;
     }
@@ -93,4 +93,5 @@ namespace Matrix3D
 
         return {res_hom[0], res_hom[1], res_hom[2]};
     }
+
 }

src/main.cpp

@@ -1,61 +1,17 @@
 #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));
+    // Zufall initialisieren
+    srand(time(NULL));
 
-    InitWindow(800, 600, "3D Memory Game");
+    // Fenster und Kamera
+    InitWindow(800, 600, "3D Memory Game with Matrix3D Library");
     SetTargetFPS(60);
 
     Camera3D camera{};
@@ -65,105 +21,79 @@ int main()
     camera.fovy     = 45.0f;
     camera.projection = CAMERA_PERSPECTIVE;
 
-    GameScreen currentScreen = MENU;
+    // 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;
-
-    int selectedPairs = 3;
-    float flipSpeed = 180.0f; // Grad pro Sekunde
-
+    float flipSpeed = 5.0f;  // Drehgeschwindigkeit
     bool gameWon = false;
-    bool timerStarted = false;
-    double startTime = 0.0;
-    double endTime = 0.0;
 
+    // -----------------------------------------------------------
+    // Hauptspielschleife
+    // -----------------------------------------------------------
     while (!WindowShouldClose())
     {
-        // ---------------- UPDATE ----------------
-        switch (currentScreen)
+        // Klick-Erkennung
+        if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
         {
-            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;
+            Vector2 mouse = GetMousePosition();
 
             for (auto &c : cubes)
             {
-                        if (c.IsMatched() || c.IsFlipped()) continue;
+                if (!c.IsFlipped() && !c.IsMatched())
+                {
+                    Vector2 screenPos = GetWorldToScreen({c.GetPosition().x, c.GetPosition().y, c.GetPosition().z}, camera);
 
-                        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();
+                    if (fabs(mouse.x - screenPos.x) < 40 && fabs(mouse.y - screenPos.y) < 40)
+                        c.FlipForward();
                 }
             }
         }
 
-                // Animation
+        // Animation aller Würfel
         for (auto &c : cubes)
+        {
             c.Update(flipSpeed);
 
-                // Matching
-                if (first && second && first->IsFlipped() && second->IsFlipped())
+            // Sobald ein Würfel vollständig umgedreht ist → merken
+            if (c.IsFlipped() && !c.IsMatched())
             {
-                    if (first->GetColor().r == second->GetColor().r &&
-                        first->GetColor().g == second->GetColor().g &&
-                        first->GetColor().b == second->GetColor().b)
+                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);
@@ -174,50 +104,29 @@ int main()
                 second->FlipBackward();
             }
 
-                    first = nullptr;
-                    second = nullptr;
+            first = second = nullptr;
         }
 
+        // Gewinnprüfung
         if (!gameWon)
-                {
-                    gameWon = std::all_of(cubes.begin(), cubes.end(),
-                        [](const gamecube& c){ return c.IsMatched(); });
-                    if (gameWon)
-                        endTime = GetTime() - startTime;
-                }
-                break;
-            }
-        }
+            gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
 
-        // ---------------- DRAW ----------------
+        // -----------------------------------------------------------
+        // Zeichnen
+        // -----------------------------------------------------------
         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();
+
+        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);
-            }
+            DrawText("Congrats! You found all pairs!", 150, 260, 30, DARKBLUE);
         else
-            {
-                char buf[64];
-                sprintf(buf, "Time: %.2f", GetTime() - startTime);
-                DrawText(buf, 10, 10, 20, DARKGRAY);
-            }
-        }
+            DrawText("Flip 2 cubes - find matching pairs!", 10, 10, 20, DARKGRAY);
 
         EndDrawing();
     }

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.
-============================================================