bhattial100541/Prog3b_651
1
2
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects 2 Releases Wiki Activity

Compare commits

base: bhattial100541:main
Branches Tags
bhattial100541:main
bhattial100541:Punktestand
bhattial100541:project_leader
bhattial100541:versioon_0.1.4
bhattial100541:project_tester
bhattial100541:project_developer
bhattial100541:architect
..
compare: bhattial100541:Punktestand
Branches Tags
bhattial100541:main
bhattial100541:Punktestand
bhattial100541:project_leader
bhattial100541:versioon_0.1.4
bhattial100541:project_tester
bhattial100541:project_developer
bhattial100541:architect

2 Commits
main ... Punktestan

Author SHA1 Message Date
bhattial100541
64adfd8a39 .. 2025-12-15 12:03:00 +01:00
bhattial100541
7bd8731cbb Puntestand einbauen 2025-12-14 04:34:32 +01:00
8 changed files with 357 additions and 135 deletions
Show Stats Expand all files Collapse all files

BIN
.DS_Store vendored Normal file
View File

Binary file not shown.

8
.idea/.gitignore generated vendored Normal file
View File

@ -0,0 +1,8 @@
# Default ignored files
/shelf/
/workspace.xml
# Editor-based HTTP Client requests
/httpRequests/
# Datasource local storage ignored files
/dataSources/
/dataSources.local.xml

6
.idea/vcs.xml generated Normal file
View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="" vcs="Git" />
</component>
</project>

10
.vscode/launch.json vendored Normal file
View File

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

34
CMakeLists.txt
View File

@ -27,20 +27,19 @@ target_include_directories(Prog3B PRIVATE
${CMAKE_CURRENT_LIST_DIR}/includes ${CMAKE_CURRENT_LIST_DIR}/includes
${CMAKE_CURRENT_LIST_DIR}/raylib ${CMAKE_CURRENT_LIST_DIR}/raylib
) )
target_link_libraries(${EXECUTABLE_NAME} PRIVATE target_link_libraries(${EXECUTABLE_NAME} PRIVATE
#${CMAKE_CURRENT_LIST_DIR}/windows/libgamematrix.a ${CMAKE_CURRENT_LIST_DIR}/mac_x86/libgamematrix.a
${CMAKE_CURRENT_LIST_DIR}/windows/libraylib.a raylib
opengl32
gdi32
m
winmm
) )
# Checks if OSX and links appropriate frameworks (Only required on MacOS) # Checks if OSX and links appropriate frameworks (Only required on MacOS)
if (APPLE) if (APPLE)
target_link_libraries(Prog3B "-framework IOKit") target_link_libraries(Prog3B PRIVATE "-framework IOKit"
target_link_libraries(Prog3B "-framework Cocoa") "-framework Cocoa"
target_link_libraries(Prog3B "-framework OpenGL") "-framework OpenGL"
)
endif() endif()
add_executable(tests add_executable(tests
@ -49,15 +48,12 @@ add_executable(tests
) )
target_include_directories(tests PRIVATE ${INCLUDE_DIRS}) 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()

37
src/gamecube.cpp
View File

@ -1,7 +1,14 @@
<<<<<<< HEAD
#include "gamecube.h"
=======
#include "raylib.h" #include "raylib.h"
#include "gamecube.h" #include "gamecube.h"
#pragma once
gamecube::gamecube(const Vec3& pos, Color col)
>>>>>>> 5fc4346 (funktioniert, 3 oder 6 + Timer komplett)
gamecube::gamecube(const Vec3 &pos, Color col)
: position(pos), color(col) {} : position(pos), color(col) {}
void gamecube::Update(float flipSpeed) void gamecube::Update(float flipSpeed)
@ -28,8 +35,8 @@ void gamecube::Update(float flipSpeed)
} }
} }
void gamecube::FlipForward() { flippingForward = true; } void gamecube::FlipForward() { flippingForward = true; }
void gamecube::FlipBackward() { flippingBackward = true; } void gamecube::FlipBackward() { flippingBackward = true; }
bool gamecube::IsFlipped() const { return flipped; } bool gamecube::IsFlipped() const { return flipped; }
bool gamecube::IsMatched() const { return matched; } bool gamecube::IsMatched() const { return matched; }
@ -39,28 +46,34 @@ void gamecube::Draw() const
{ {
rlPushMatrix(); rlPushMatrix();
auto matrix_a = Matrix3D::gameMatrix::translate( // Matrizen für Rotation und Translation erzeugen
{ position.x, position.y, position.z } auto matrix_a = Matrix3D::gameMatrix::translate({ position.x, position.y, position.z});
);
auto matrix_b = Matrix3D::gameMatrix::rot3D(rotation, 'y'); auto matrix_b = Matrix3D::gameMatrix::rot3D(rotation, 'y');
// Matrizen multiplizieren (Translation * Rotation)
auto model = Matrix3D::gameMatrix::matmul(matrix_a, matrix_b); auto model = Matrix3D::gameMatrix::matmul(matrix_a, matrix_b);
// transform for raylib matrix
float f[16]; float f[16];
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
f[j * 4 + i] = model[i][j]; f[j * 4 + i] = model[i][j];
rlMultMatrixf(f); rlMultMatrixf(f);
if (rotation < 90.0f) if (rotation < 90.0f)
DrawCube({ 0, 0, 0 }, 1, 1, 1, GRAY); DrawCube({0,0,0}, 1,1,1, GRAY);
else 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(); rlPopMatrix();
} }
Vec3 gamecube::GetPosition() const { return position; } Vec3 gamecube::GetPosition() const { return position; }
float gamecube::GetRotationY() const { return rotation; } <<<<<<< HEAD
float gamecube::GetRotationY() const { return rotation; }
=======
float gamecube::GetRotationY() const { return rotation; }
>>>>>>> 5fc4346 (funktioniert, 3 oder 6 + Timer komplett)

30
src/gamematrix.cpp
View File

@ -1,4 +1,9 @@
<<<<<<< HEAD
// //
=======
//
>>>>>>> 5fc4346 (funktioniert, 3 oder 6 + Timer komplett)
// Created by bakee on 03.11.2025. // Created by bakee on 03.11.2025.
// //
#include "gamematrix.h" #include "gamematrix.h"
@ -37,9 +42,9 @@ namespace Matrix3D
{ {
Mat4 result = identity(); Mat4 result = identity();
result[0][3] = pos[0]; result[0][3] = pos[0]; // x
result[1][3] = pos[1]; result[1][3] = pos[1]; // y
result[2][3] = pos[2]; result[2][3] = pos[2]; // z
return result; return result;
} }
@ -56,16 +61,16 @@ namespace Matrix3D
switch (axis) switch (axis)
{ {
case 'x': case 'x':
result[1][1] = c; result[1][2] = -s; result[1][1] = c; result[1][2] = -s;
result[2][1] = s; result[2][2] = c; result[2][1] = s; result[2][2] = c;
break; break;
case 'y': case 'y':
result[0][0] = c; result[0][2] = s; result[0][0] = c; result[0][2] = s;
result[2][0] = -s; result[2][2] = c; result[2][0] = -s; result[2][2] = c;
break; break;
case 'z': case 'z':
result[0][0] = c; result[0][1] = -s; result[0][0] = c; result[0][1] = -s;
result[1][0] = s; result[1][1] = c; result[1][0] = s; result[1][1] = c;
break; break;
default: default:
break; break;
@ -80,7 +85,7 @@ namespace Matrix3D
Vec3 operator*(const Mat4& m, const Vec3& v) 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 = {}; Vec4 res_hom = {};
for (int i = 0; i < 4; ++i) for (int i = 0; i < 4; ++i)
@ -91,6 +96,11 @@ namespace Matrix3D
} }
} }
return { res_hom[0], res_hom[1], res_hom[2] }; return {res_hom[0], res_hom[1], res_hom[2]};
} }
<<<<<<< HEAD
} }
=======
}
>>>>>>> 5fc4346 (funktioniert, 3 oder 6 + Timer komplett)

365
src/main.cpp
View File

@ -1,132 +1,282 @@
#include "gamecube.h" #include "gamecube.h"
#include "raylib.h"
#include <algorithm> #include <algorithm>
#include <ctime> #include <ctime>
#include <vector> #include <vector>
#include <cstdio> #include "raylib.h" // Stellen Sie sicher, dass raylib.h hier oder in gamecube.h inkludiert ist
// ----------------------------------------------------------- // -----------------------------------------------------------
// 3D Memory Game – Hauptprogramm // 3D Memory Game – Hauptprogramm
// ----------------------------------------------------------- // -----------------------------------------------------------
enum GameScreen { MENU = 0, GAMEPLAY }; enum GameScreen {MENU = 0, GAMEPLAY};
void SetupGame(std::vector<gamecube>& cubes, int pairs) void SetupGame(std::vector<gamecube>& cubes, int pairs)
{ {
cubes.clear(); cubes.clear();
Color colors[] = {RED, GREEN, BLUE, YELLOW, ORANGE, PURPLE, WHITE, SKYBLUE};
Color colors[] = { RED, GREEN, BLUE, YELLOW, ORANGE, PURPLE, WHITE, SKYBLUE }; std::vector<Vec3> positions;
int count = pairs * 2; int count = pairs * 2;
int cols = (count > 6) ? 4 : 3; int cols = 3;
int rows = (count > 6) ? 3 : 2; int rows = 2;
if (count > 6) {
std::vector<Vec3> positions; cols = 4;
rows = 3;
}
int index = 0; int index = 0;
for (int r = 0; r < rows && index < count; ++r) // Generiert Positionen basierend auf der Größe
{ 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, positions.push_back({(float)c * 2.0f - (cols -1 ), 0.0f, (float)r * 2.0f - (rows -1)});
(float)r * 2.0f - (rows - 1) });
index++; index++;
} }
} }
std::vector<Color> colorPool; 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]);
colorPool.push_back(colors[i]); colorPool.push_back(colors[i]);
} }
// Shuffle // Fisher-Yates Shuffle
for (int i = (int)colorPool.size() - 1; i > 0; --i) for (int i= colorPool.size() -1; i > 0; --i) {
{
int j = rand() % (i + 1); int j = rand() % (i + 1);
std::swap(colorPool[i], colorPool[j]); std::swap(colorPool[i], colorPool[j]);
} }
for (int i = 0; i < count; ++i) // Würfel erstellen
for (int i = 0; i < count; i++)
cubes.emplace_back(positions[i], colorPool[i]); cubes.emplace_back(positions[i], colorPool[i]);
} }
int main() int main()
{ {
srand((unsigned)time(nullptr)); // Zufall initialisieren#include "gamecube.h"
//#include <algorithm>
InitWindow(800, 600, "3D Memory Game"); //#include <ctime>
SetTargetFPS(60); //
//// -----------------------------------------------------------
Camera3D camera{}; //// 3D Memory Game – Hauptprogramm
camera.position = { 6.0f, 6.0f, 6.0f }; //// -----------------------------------------------------------
camera.target = { 0.0f, 0.0f, 0.0f }; //int main()
camera.up = { 0.0f, 1.0f, 0.0f }; //{
camera.fovy = 45.0f; // // Zufall initialisieren
camera.projection = CAMERA_PERSPECTIVE; // 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; GameScreen currentScreen = MENU;
int selectedPairs = 3;
// 1. SPIELSPEZIFISCHE VARIABLEN HIER DEKLARIEREN (ohne Initialisierung)
std::vector<gamecube> cubes; std::vector<gamecube> cubes;
gamecube* first = nullptr; gamecube* first = nullptr;
gamecube* second = nullptr; gamecube* second = nullptr;
float flipSpeed = 5.0f; // Drehgeschwindigkeit
int selectedPairs = 3;
float flipSpeed = 180.0f; // Grad pro Sekunde
bool gameWon = false; bool gameWon = false;
bool timerStarted = false; int moves = 0;
double startTime = 0.0;
double endTime = 0.0;
// 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;
// -----------------------------------------------------------
// Hauptspielschleife
// -----------------------------------------------------------
while (!WindowShouldClose()) while (!WindowShouldClose())
{ {
// ---------------- UPDATE ---------------- // -------------------------------------------------------
// UPDATE-LOGIK NACH ZUSTAND
// -------------------------------------------------------
switch (currentScreen) switch (currentScreen)
{ {
case MENU: case MENU:
{ {
if (IsKeyPressed(KEY_THREE)) // Menü-Abfrage: Auf Tastendruck warten
{ if (IsKeyPressed(KEY_THREE)) {
selectedPairs = 3; selectedPairs = 3; // 6 Würfel
SetupGame(cubes, selectedPairs); SetupGame(cubes, selectedPairs);
currentScreen = GAMEPLAY;
gameWon = false; gameWon = false;
first = second = nullptr; first = second = nullptr;
timerStarted = false;
}
else if (IsKeyPressed(KEY_SIX))
{
selectedPairs = 6;
SetupGame(cubes, selectedPairs);
currentScreen = GAMEPLAY; currentScreen = GAMEPLAY;
timerStarted = false; // Timer-Reset
moves = 0;
} else if (IsKeyPressed(KEY_SIX)) {
selectedPairs = 6; // 12 Würfel
SetupGame(cubes, selectedPairs);
gameWon = false; gameWon = false;
first = second = nullptr; first = second = nullptr;
timerStarted = false; currentScreen = GAMEPLAY;
timerStarted = false; // Timer-Reset
moves = 0;
} }
break; break;
} }
case GAMEPLAY: case GAMEPLAY:
{ {
// Timer starten
if (!timerStarted) if (!timerStarted)
{ {
startTime = GetTime(); startTime = GetTime();
timerStarted = true; timerStarted = true;
} }
// Klick-Erkennung (Ray Picking) – nur wenn noch nicht 2 ausgewählt sind
// Klick-Erkennung mit Ray if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && (second == nullptr))
if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && second == nullptr)
{ {
Ray ray = GetMouseRay(GetMousePosition(), camera); Vector2 mouse = GetMousePosition();
gamecube* hit = nullptr; Ray ray = GetMouseRay(mouse, camera);
gamecube* hitCube = nullptr;
float bestDist = 1e9f; float bestDist = 1e9f;
for (auto& c : cubes) for (auto &c : cubes)
{ {
if (c.IsMatched() || c.IsFlipped()) continue; if (c.IsMatched() || c.IsFlipped()) continue;
Vec3 p = c.GetPosition(); Vec3 p = c.GetPosition();
BoundingBox box; BoundingBox box;
box.min = { p.x - 0.75f, p.y - 0.75f, p.z - 0.75f }; 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 }; box.max = { p.x + 0.75f, p.y + 0.75f, p.z + 0.75f };
@ -135,35 +285,40 @@ int main()
if (col.hit && col.distance < bestDist) if (col.hit && col.distance < bestDist)
{ {
bestDist = col.distance; bestDist = col.distance;
hit = &c; hitCube = &c;
} }
} }
if (hit) if (hitCube)
{ {
if (!first) if (!first)
{ {
first = hit; first = hitCube;
first->FlipForward(); first->FlipForward();
} }
else if (hit != first) else if (hitCube != first)
{ {
second = hit; second = hitCube;
second->FlipForward(); second->FlipForward();
} }
} }
} }
// Animation // Animation aller Würfel (KEINE first/second Auto-Zuweisung hier!)
for (auto& c : cubes) for (auto &c : cubes)
{
c.Update(flipSpeed); c.Update(flipSpeed);
}
// Matching // Matching-Logik: erst wenn beide vollständig umgedreht sind
if (first && second && first->IsFlipped() && second->IsFlipped()) if (first && second && first->IsFlipped() && second->IsFlipped())
{ {
if (first->GetColor().r == second->GetColor().r && moves++;
first->GetColor().g == second->GetColor().g &&
first->GetColor().b == second->GetColor().b) Color col1 = first->GetColor();
Color col2 = second->GetColor();
if (col1.r == col2.r && col1.g == col2.g && col1.b == col2.b)
{ {
first->SetMatched(true); first->SetMatched(true);
second->SetMatched(true); second->SetMatched(true);
@ -178,45 +333,69 @@ int main()
second = nullptr; second = nullptr;
} }
// Gewinnprüfung
if (!gameWon) if (!gameWon)
{ {
gameWon = std::all_of(cubes.begin(), cubes.end(), // Prüft, ob ALLE Würfel gematcht sind
[](const gamecube& c){ return c.IsMatched(); }); gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
if (gameWon) if (gameWon)
{
endTime = GetTime() - startTime; endTime = GetTime() - startTime;
}
} }
break; break;
} } // ENDE GAMEPLAY UPDATE
} }
// ---------------- DRAW ---------------- // -----------------------------------------------------------
// ZEICHNEN NACH ZUSTAND
// -----------------------------------------------------------
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
if (currentScreen == MENU) switch (currentScreen)
{ {
DrawText("3D MEMORY SPIEL", 200, 80, 40, DARKGRAY); case MENU:
DrawText("[3] = 3 Paare", 200, 200, 24, BLUE); {
DrawText("[6] = 6 Paare", 200, 240, 24, BLUE); // Menü-Darstellung
} DrawText("3D MEMORY SPIEL", GetScreenWidth() / 2 - MeasureText("3D MEMORY SPIEL", 50) / 2, 80, 50, DARKGRAY);
else DrawText("Waehlen Sie die Spielgroesse:", 50, 200, 25, BLACK);
{ DrawText("Druecken Sie [3] fuer 3 Paare (6 Wuerfel)", 50, 240, 20, BLUE);
BeginMode3D(camera); DrawText("Druecken Sie [6] fuer 6 Paare (12 Wuerfel)", 50, 280, 20, BLUE);
for (auto& c : cubes) c.Draw(); break;
EndMode3D(); }
if (gameWon) case GAMEPLAY:
{ {
char buf[64]; // Spiel-Darstellung
sprintf(buf, "Gewonnen in %.2f Sekunden", endTime); BeginMode3D(camera);
DrawText(buf, 150, 260, 30, DARKGREEN);
} for (auto &c : cubes)
else c.Draw();
{
char buf[64]; EndMode3D();
sprintf(buf, "Time: %.2f", GetTime() - startTime);
DrawText(buf, 10, 10, 20, DARKGRAY); if (gameWon)
} {
DrawText("Congrats! You found all pairs!", 150, 260, 30, DARKBLUE);
char buffer[64];
sprintf(buffer, "Cleared in %.2f seconds", endTime);
DrawText(buffer, 150, 300, 28, DARKGREEN);
}
else
{
DrawText("Flip 2 cubes - find matching pairs!", 10, 10, 20, DARKGRAY);
char liveBuf[64];
sprintf(liveBuf, "Time: %.2f", GetTime() - startTime);
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(); EndDrawing();