Merge remote-tracking branch 'origin/project_developer' into project_tester

2025-11-16 19:58:48 +01:00
parent 0f1d80fa82 e4e3bcf558
commit 00328cf495
6 changed files with 107 additions and 0 deletions
@@ -0,0 +1,66 @@
+#include "gamecube.h"
+
+gamecube::gamecube(const Vec3 &pos, Color col)
+    : position(pos), color(col) {}
+
+void gamecube::Update(float flipSpeed)
+{
+    if (flippingForward)
+    {
+        rotation += flipSpeed;
+        if (rotation >= 180.0f)
+        {
+            rotation = 180.0f;
+            flippingForward = false;
+            flipped = true;
+        }
+    }
+    else if (flippingBackward)
+    {
+        rotation -= flipSpeed;
+        if (rotation <= 0.0f)
+        {
+            rotation = 0.0f;
+            flippingBackward = false;
+            flipped = false;
+        }
+    }
+}
+
+void gamecube::FlipForward()   { flippingForward = true; }
+void gamecube::FlipBackward()  { flippingBackward = true; }
+
+bool gamecube::IsFlipped() const { return flipped; }
+bool gamecube::IsMatched() const { return matched; }
+void gamecube::SetMatched(bool m) { matched = m; }
+
+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');
+
+    // 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);
+    else
+        DrawCube({0,0,0}, 1,1,1, color);
+
+    DrawCubeWires({0,0,0}, 1,1,1, BLACK);
+
+    rlPopMatrix();
+}
+
+Vec3 gamecube::GetPosition() const     { return position; }
+float gamecube::GetRotationY() const   { return rotation; }
@@ -0,0 +1,97 @@
+//
+// 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]};
+    }
+
+}
@@ -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;
+}