resolving conflicts

.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,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>

.vscode/launch.json

@@ -1,10 +0,0 @@
-{
-    // 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

@@ -27,19 +27,20 @@ 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}/mac_x86/libgamematrix.a
+        #${CMAKE_CURRENT_LIST_DIR}/windows/libgamematrix.a
-        raylib
+        ${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 PRIVATE "-framework IOKit"
+        target_link_libraries(Prog3B "-framework IOKit")
-        "-framework Cocoa"
+        target_link_libraries(Prog3B "-framework Cocoa")
-         "-framework OpenGL"
+        target_link_libraries(Prog3B "-framework OpenGL")
-        )
 endif()
 
 add_executable(tests
@@ -48,12 +49,15 @@ add_executable(tests
 )
 target_include_directories(tests PRIVATE ${INCLUDE_DIRS})
 
-target_link_libraries(tests PRIVATE)
+target_link_libraries(tests PRIVATE
+        opengl32
+        gdi32
+        winmm
+)
 
-#if (APPLE)
+if (APPLE)
-        #target_link_libraries(Prog3B PRIVATE "-framework IOKit")
+        target_link_libraries(Prog3B PRIVATE "-framework IOKit")
-        #target_link_libraries(Prog3B PRIVATE "-framework Cocoa")
+        target_link_libraries(Prog3B PRIVATE "-framework Cocoa")
-        #target_link_libraries(Prog3B PRIVATE "-framework OpenGL")
+        target_link_libraries(Prog3B PRIVATE "-framework OpenGL")
-
+endif()
-#endif()
 

src/gamecube.cpp

@@ -1,12 +1,5 @@
-<<<<<<< HEAD
-#include "gamecube.h"
-=======
 #include "raylib.h"
 #include "gamecube.h"
-#pragma once
-
-
->>>>>>> 5fc4346 (funktioniert, 3 oder 6 + Timer komplett)
 
 gamecube::gamecube(const Vec3& pos, Color col)
     : position(pos), color(col) {}
@@ -46,18 +39,17 @@ void gamecube::Draw() const
 {
     rlPushMatrix();
 
-    // Matrizen für Rotation und Translation erzeugen
+    auto matrix_a = Matrix3D::gameMatrix::translate(
-    auto matrix_a = Matrix3D::gameMatrix::translate({ position.x, position.y, position.z});
+        { 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)
@@ -71,9 +63,4 @@ void gamecube::Draw() const
 }
 
 Vec3 gamecube::GetPosition() const { return position; }
-<<<<<<< HEAD
 float gamecube::GetRotationY() const { return rotation; }
-=======
-float gamecube::GetRotationY() const   { return rotation; }
-
->>>>>>> 5fc4346 (funktioniert, 3 oder 6 + Timer komplett)

src/gamematrix.cpp

@@ -1,9 +1,4 @@
-<<<<<<< HEAD
 //
-=======
-
- //
->>>>>>> 5fc4346 (funktioniert, 3 oder 6 + Timer komplett)
 // Created by bakee on 03.11.2025.
 //
 #include "gamematrix.h"
@@ -42,9 +37,9 @@ namespace Matrix3D
     {
         Mat4 result = identity();
 
-        result[0][3] = pos[0]; // x
+        result[0][3] = pos[0];
-        result[1][3] = pos[1]; // y
+        result[1][3] = pos[1];
-        result[2][3] = pos[2]; // z
+        result[2][3] = pos[2];
 
         return result;
     }
@@ -98,9 +93,4 @@ namespace Matrix3D
 
         return { res_hom[0], res_hom[1], res_hom[2] };
     }
-
-<<<<<<< HEAD
 }
-=======
-}
->>>>>>> 5fc4346 (funktioniert, 3 oder 6 + Timer komplett)

src/main.cpp

@@ -1,9 +1,9 @@
 #include "gamecube.h"
+#include "raylib.h"
 #include <algorithm>
 #include <ctime>
 #include <vector>
-#include "raylib.h" // Stellen Sie sicher, dass raylib.h hier oder in gamecube.h inkludiert ist
+#include <cstdio>
-
 
 // -----------------------------------------------------------
 // 3D Memory Game – Hauptprogramm
@@ -11,205 +11,51 @@
 
 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 cols = (count > 6) ? 4 : 3;
-    int rows = 2;
+    int rows = (count > 6) ? 3 : 2;
-    if (count > 6) {
+
-        cols = 4;
+    std::vector<Vec3> positions;
-        rows = 3;
-    }
     int index = 0;
-    // Generiert Positionen basierend auf der Größe
+    for (int r = 0; r < rows && index < count; ++r)
-    for (int r = 0; r < rows && index < count; ++r) {
+    {
-        for (int c = 0; c < cols && index < count; ++c) {
+        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)});
+            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++) {
+    for (int i = 0; i < pairs; ++i)
+    {
         colorPool.push_back(colors[i]);
         colorPool.push_back(colors[i]);
     }
 
-    // Fisher-Yates Shuffle
+    // Shuffle
-    for (int i= colorPool.size() -1; i > 0; --i) {
+    for (int i = (int)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)
-    for (int i = 0; i < count; i++)
         cubes.emplace_back(positions[i], colorPool[i]);
-
 }
 
 int main()
 {
-    // Zufall initialisieren#include "gamecube.h"
+    srand((unsigned)time(nullptr));
-    //#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;
+    InitWindow(800, 600, "3D Memory Game");
-    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;
-    int moves = 0;
-
-
-    // Fenster und Kamera
-    InitWindow(800, 600, "3D Memory Game with Matrix3D Library");
     SetTargetFPS(60);
 
     Camera3D camera{};
@@ -219,56 +65,61 @@ int main()
     camera.fovy     = 45.0f;
     camera.projection = CAMERA_PERSPECTIVE;
 
-    // -----------------------------------------------------------
+    GameScreen currentScreen = MENU;
-    // Hauptspielschleife
+
-    // -----------------------------------------------------------
+    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 ----------------
-        // UPDATE-LOGIK NACH ZUSTAND
-        // -------------------------------------------------------
         switch (currentScreen)
         {
             case MENU:
             {
-                // Menü-Abfrage: Auf Tastendruck warten
+                if (IsKeyPressed(KEY_THREE))
-                if (IsKeyPressed(KEY_THREE)) {
+                {
-                    selectedPairs = 3; // 6 Würfel
+                    selectedPairs = 3;
                     SetupGame(cubes, selectedPairs);
+                    currentScreen = GAMEPLAY;
                     gameWon = false;
                     first = second = nullptr;
-                    currentScreen = GAMEPLAY;
+                    timerStarted = false;
-                    timerStarted = false; // Timer-Reset
+                }
-                    moves = 0;
+                else if (IsKeyPressed(KEY_SIX))
-
+                {
-                } else if (IsKeyPressed(KEY_SIX)) {
+                    selectedPairs = 6;
-                    selectedPairs = 6; // 12 Würfel
                     SetupGame(cubes, selectedPairs);
+                    currentScreen = GAMEPLAY;
                     gameWon = false;
                     first = second = nullptr;
-                    currentScreen = GAMEPLAY;
+                    timerStarted = false;
-                    timerStarted = false; // Timer-Reset
-                    moves = 0;
-
                 }
                 break;
             }
 
             case GAMEPLAY:
             {
-                // Timer starten
                 if (!timerStarted)
                 {
                     startTime = GetTime();
                     timerStarted = true;
                 }
-                // Klick-Erkennung (Ray Picking) – nur wenn noch nicht 2 ausgewählt sind
-                if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && (second == nullptr))
-                {
-                    Vector2 mouse = GetMousePosition();
-                    Ray ray = GetMouseRay(mouse, camera);
 
-                    gamecube* hitCube = nullptr;
+                // 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)
@@ -276,7 +127,6 @@ int main()
                         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 };
@@ -285,40 +135,35 @@ int main()
                         if (col.hit && col.distance < bestDist)
                         {
                             bestDist = col.distance;
-                            hitCube = &c;
+                            hit = &c;
                         }
                     }
 
-                    if (hitCube)
+                    if (hit)
                     {
                         if (!first)
                         {
-                            first = hitCube;
+                            first = hit;
                             first->FlipForward();
                         }
-                        else if (hitCube != first)
+                        else if (hit != first)
                         {
-                            second = hitCube;
+                            second = hit;
                             second->FlipForward();
                         }
                     }
                 }
 
-                // Animation aller Würfel (KEINE first/second Auto-Zuweisung hier!)
+                // Animation
                 for (auto& c : cubes)
-                {
                     c.Update(flipSpeed);
-                }
 
-                // Matching-Logik: erst wenn beide vollständig umgedreht sind
+                // Matching
                 if (first && second && first->IsFlipped() && second->IsFlipped())
                 {
-                    moves++;
+                    if (first->GetColor().r == second->GetColor().r &&
-
+                        first->GetColor().g == second->GetColor().g &&
-                    Color col1 = first->GetColor();
+                        first->GetColor().b == second->GetColor().b)
-                    Color col2 = second->GetColor();
-
-                    if (col1.r == col2.r && col1.g == col2.g && col1.b == col2.b)
                     {
                         first->SetMatched(true);
                         second->SetMatched(true);
@@ -333,69 +178,45 @@ int main()
                     second = nullptr;
                 }
 
-                // Gewinnprüfung
                 if (!gameWon)
                 {
-                    // Prüft, ob ALLE Würfel gematcht sind
+                    gameWon = std::all_of(cubes.begin(), cubes.end(),
-                    gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
+                        [](const gamecube& c){ return c.IsMatched(); });
                     if (gameWon)
-                    {
                         endTime = GetTime() - startTime;
                 }
-                }
                 break;
-            } // ENDE GAMEPLAY UPDATE
+            }
         }
 
-        // -----------------------------------------------------------
+        // ---------------- DRAW ----------------
-        // ZEICHNEN NACH ZUSTAND
-        // -----------------------------------------------------------
         BeginDrawing();
         ClearBackground(RAYWHITE);
 
-        switch (currentScreen)
+        if (currentScreen == MENU)
         {
-            case MENU:
+            DrawText("3D MEMORY SPIEL", 200, 80, 40, DARKGRAY);
-            {
+            DrawText("[3]  = 3 Paare", 200, 200, 24, BLUE);
-                // Menü-Darstellung
+            DrawText("[6]  = 6 Paare", 200, 240, 24, BLUE);
-                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;
         }
-
+        else
-            case GAMEPLAY:
         {
-                // Spiel-Darstellung
             BeginMode3D(camera);
-
+            for (auto& c : cubes) c.Draw();
-                for (auto &c : cubes)
-                    c.Draw();
-
             EndMode3D();
 
             if (gameWon)
             {
-                    DrawText("Congrats! You found all pairs!", 150, 260, 30, DARKBLUE);
+                char buf[64];
-                    char buffer[64];
+                sprintf(buf, "Gewonnen in %.2f Sekunden", endTime);
-                    sprintf(buffer, "Cleared in %.2f seconds", endTime);
+                DrawText(buf, 150, 260, 30, DARKGREEN);
-                    DrawText(buffer, 150, 300, 28, DARKGREEN);
             }
             else
             {
-                    DrawText("Flip 2 cubes - find matching pairs!", 10, 10, 20, DARKGRAY);
+                char buf[64];
-                    char liveBuf[64];
+                sprintf(buf, "Time: %.2f", GetTime() - startTime);
-                    sprintf(liveBuf, "Time: %.2f", GetTime() - startTime);
+                DrawText(buf, 10, 10, 20, DARKGRAY);
-                    DrawText(liveBuf, 10, 40, 20, DARKGRAY);
-
-                    char moveBuf[64];
-                    snprintf(moveBuf, sizeof(moveBuf), "Moves: %d", moves);
-                    DrawText(moveBuf, 10, 70, 20, DARKGRAY);
-
             }
-                break;
-            } // ENDE GAMEPLAY DRAW
         }
 
         EndDrawing();