CMakeLists.txt

@@ -1,35 +0,0 @@
-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()

gamecube.cpp

@@ -1,66 +0,0 @@
-#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

@@ -1,34 +0,0 @@
-#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

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

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