ARCH: Design-Dokumentation final

.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

@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.28)
+project(Prog3B)
+set(EXECUTABLE_NAME Prog3B)
+
+# Generate compile_commands.json
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+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)
+endif()
+
+set(SRC_FILES
+        ${CMAKE_CURRENT_LIST_DIR}/main.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/gamecube.cpp
+)
+
+set(INCLUDE_DIRS
+        ${CMAKE_CURRENT_LIST_DIR}/linux
+)
+
+add_executable(${EXECUTABLE_NAME} ${SRC_FILES})
+target_include_directories(${EXECUTABLE_NAME} PRIVATE ${INCLUDE_DIRS})
+target_link_libraries(${EXECUTABLE_NAME} PRIVATE
+        ${CMAKE_CURRENT_LIST_DIR}/linux/libgamematrix.a
+        ${CMAKE_CURRENT_LIST_DIR}/linux/libraylib.a
+)
+
+# 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")
+endif()

design.txt

@@ -0,0 +1,75 @@
+
+Eine  Mücke
+
+
+========================================================
+Projekt: gamematrix (C++ Library)
+Rolle: Architekt
+Datei: design.txt
+Datum: 16.11.25
+Team:bhattial100541
+========================================================
+
+# ----------------------------
+# 1. Projektstruktur / Namespace
+# ----------------------------
+Namespace: Matrix3D
+
+Ziel: Saubere Trennung der Bibliothek, Vermeidung von Namenskonflikten.
+
+Beispiel:
+namespace Matrix3D {
+    // Funktionen, ggf Klasse(n)
+}
+
+# ----------------------------
+# 2. Datenstrukturen / Klassen
+# ----------------------------
+Listen Sie die Klassen oder Structs auf, die verwendet werden:
+
+Name	Typ	Beschreibung
+Vec3	struct Vec3 (z.B. std::array<double, 3>)	3D-Vektor (x, y, z)
+Mat4	std::array<std::array<double,4>,4>	4x4-Matrix (homogen)
+Vec4	struct Vec4 (z.B. std::array<double, 4>)	4D-Vektor (Homogene Koordinaten)
+gameMatrix	class gameMatrix (Container für statische Methoden)	Statische Klasse zur Erzeugung von Transformationsmatrizen
+# ----------------------------
+# 3. Operatoren / Templates
+# ----------------------------
+Welche Operatoren oder Templates sollen definiert werden?
+
+- Templates für unterschiedliche Datentypen? ☐  Nein
+- Operatoren:
+    - Mat4 * Mat4(Matrix-Matrix-Multiplikation)
+    - Mat4 * Vec3(Matrix-Vektor-Multiplikation unter Nutzung homogener Koordinaten)
+
+# ----------------------------
+# 4. Funktionen / Schnittstellen
+# ----------------------------
+Liste der Funktionen mit Eingabe/Ausgabe und kurzer Beschreibung:
+
+Funktion	Eingabe	Ausgabe	Kurzbeschreibung
+matmul	const Mat4& A, const Mat4& B	Mat4	Matrixmultiplikation 4x4
+translate	const Vec3& pos	Mat4	Erzeugt eine Verschiebungstransformationsmatrix
+rot3D	double angle_deg, char axis ('x', 'y', 'z')	Mat4	Erzeugt eine Rotationsmatrix um Achse x/y/z
+identity	---	Mat4	Erzeugt die 4x4-Identitätsmatrix
+operator*	const Mat4& m, const Vec3& v	Vec3	Multipliziert Matrizen mit 3D-Vektoren (Homogen-Adapter)
+
+# ----------------------------
+# 5. Designentscheidungen / Hinweise
+# ----------------------------
+- Rückgabe der Matrizen per Wert oder Referenz? Wert(Transformationsmatrizen, da diese neu erzeugt werden und Copy Elision durch moderne Compiler optimiert werden kann)
+- Verwendung von std::array oder std::vector? std::array(bessere Performance und speichereffizienter als std::vector)
+- Homogene Koordinaten für Translation / Rotation (4x4)? ☐ Ja
+- Weitere Designüberlegungen: Klasse gameMatrix dient als Utility Class, sollte keine eigene zustände besitzen, daher Funktionen sind static implementiert, folgt den OCP principle
+
+# ----------------------------
+# 6. Deliverables / Milestones
+# ----------------------------
+- design.txt fertig und im Branch architect committed
+- Übergabe an Entwickler für Implementierung
+
+========================================================
+Hinweis:
+- Dieses Dokument dient als Grundlage für die Implementierung.
+- Alle Designentscheidungen sollen klar nachvollziehbar sein.
+========================================================

gamecube.cpp

@@ -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; }

gamecube.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "gamematrix.h"
+#include "raylib.h"
+#include <rlgl.h>
+
+struct Vec3
+{
+    float x, y, z;
+};
+
+class gamecube
+{
+public:
+    gamecube(const Vec3 &pos, Color col);
+    void Update(float flipSpeed);
+    void FlipForward();
+    void FlipBackward();
+    bool IsFlipped() const;
+    bool IsMatched() const;
+    void SetMatched(bool m);
+    void Draw() const;
+    Vec3 GetPosition() const;
+    float GetRotationY() const;
+    Color GetColor() const { return color; }
+
+private:
+    Vec3 position;
+    Color color;
+    bool flipped = false;
+    bool matched = false;
+    bool flippingForward = false;
+    bool flippingBackward = false;
+    float rotation = 0.0f;
+};

gamematrix.h

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

main.cpp

@@ -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;
+}