mergeconflict

.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

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

.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": [
-        
-
-    ]
-}

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)
@@ -38,26 +39,25 @@ 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)
-        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();
 }

src/gamematrix.cpp

@@ -37,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;
     }
@@ -80,7 +80,7 @@ namespace Matrix3D
 
     Vec3 operator*(const Mat4& m, const Vec3& v)
     {
-        Vec4 v_hom = {v[0], v[1], v[2], 1.0};
+        Vec4 v_hom = { v[0], v[1], v[2], 1.0 };
         Vec4 res_hom = {};
 
         for (int i = 0; i < 4; ++i)
@@ -91,7 +91,6 @@ namespace Matrix3D
             }
         }
 
-        return {res_hom[0], res_hom[1], res_hom[2]};
+        return { res_hom[0], res_hom[1], res_hom[2] };
     }
-
 }

src/main.cpp

@@ -1,136 +1,40 @@
-#include "gamecube.h"
+#pragma once
-#include <algorithm>
+#include "gamematrix.h"
-#include <ctime>
+#include "raylib.h"
+#include <rlgl.h>
 
-// -----------------------------------------------------------
+struct Vec3
-// 3D Memory Game – Hauptprogramm
-// -----------------------------------------------------------
-int main()
 {
-    // Zufall initialisieren
+    float x, y, z;
-    srand(time(NULL));
+};
 
-    // Fenster und Kamera
+class gamecube
-    InitWindow(800, 600, "3D Memory Game with Matrix3D Library");
+{
-    SetTargetFPS(60);
+public:
+    gamecube(const Vec3 &pos, Color col);
+    void Update(float flipSpeed);
+    void FlipForward();
+    void FlipBackward();
 
-    Camera3D camera{};
+    // Wichtig für die Zustandsmaschine (LockInput-Wartezustand)
-    camera.position = {6.0f, 6.0f, 6.0f};
+    bool IsFlipping() const { return flippingForward || flippingBackward; }
-    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
+    bool IsFlipped() const;
-    Color colors[] = { RED, GREEN, BLUE };
+    bool IsMatched() const;
+    void SetMatched(bool m);
+    void Draw() const;
+    Vec3 GetPosition() const;
+    float GetRotationY() const;
 
-    // 6 Karten-Positionen im 3x2 Raster
+    // Bereits vorhanden und inline implementiert!
-    std::vector<Vec3> positions = {{-2, 0, -2}, {0, 0, -2}, {2, 0, -2},{-2, 0,  0}, {0, 0,  0}, {2, 0,  0}};
+    Color GetColor() const { return color; }
 
-    // Farben doppelt in einen Pool legen und mischen
+private:
-    std::vector<Color> colorPool;
+    Vec3 position;
-    for (int i = 0; i < 3; i++)
+    Color color;
-    {
+    bool flipped = false;
-        colorPool.push_back(colors[i]);
+    bool matched = false;
-        colorPool.push_back(colors[i]);
+    bool flippingForward = false;
-    }
+    bool flippingBackward = false;
-
+    float rotation = 0.0f;
-    // 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;
-}