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

Menu für 3, 6 Paare hingefügt

Browse Source
This commit is contained in:
PapiBigSzill 2025-12-01 12:57:11 +01:00
parent bc4f4f743d
commit c874f8b517
4 changed files with 197 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
.DS_Store vendored
View File

Binary file not shown.

1
.gitignore vendored Normal file
View File

@ -0,0 +1 @@
.idea/

31
CMakeLists.txt
View File

@ -29,18 +29,16 @@ target_include_directories(Prog3B PRIVATE
) )
target_link_libraries(${EXECUTABLE_NAME} PRIVATE target_link_libraries(${EXECUTABLE_NAME} PRIVATE
#${CMAKE_CURRENT_LIST_DIR}/windows/libgamematrix.a #${CMAKE_CURRENT_LIST_DIR}/windows/libgamematrix.a
${CMAKE_CURRENT_LIST_DIR}/windows/libraylib.a ${CMAKE_CURRENT_LIST_DIR}/mac_arm/libraylib.a
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 +47,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()

291
src/main.cpp
View File

@ -1,10 +1,58 @@
#include "gamecube.h" #include "gamecube.h"
#include <algorithm> #include <algorithm>
#include <ctime> #include <ctime>
#include <vector>
#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};
void SetupGame(std::vector<gamecube>& cubes, int pairs)
{
cubes.clear();
Color colors[] = {RED, GREEN, BLUE, YELLOW, ORANGE, PURPLE, WHITE, SKYBLUE};
std::vector<Vec3> positions;
int count = pairs * 2;
int cols = 3;
int rows = 2;
if (count > 6) {
cols = 4;
rows = 3;
}
int index = 0;
// 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) {
// Zentriert die Würfel um (0,0,0)
positions.push_back({(float)c * 2.0f - (cols -1 ), 0.0f, (float)r * 2.0f - (rows -1)});
index++;
}
}
std::vector<Color> colorPool;
for (int i = 0; i < pairs; i++) {
colorPool.push_back(colors[i]);
colorPool.push_back(colors[i]);
}
// Fisher-Yates Shuffle
for (int i= colorPool.size() -1; i > 0; --i) {
int j = rand() % (i + 1);
std::swap(colorPool[i], colorPool[j]);
}
// Würfel erstellen
for (int i = 0; i < count; i++)
cubes.emplace_back(positions[i], colorPool[i]);
}
int main() int main()
{ {
// Zufall initialisieren#include "gamecube.h" // Zufall initialisieren#include "gamecube.h"
@ -148,6 +196,15 @@ int main()
double endTime = 0.0; double endTime = 0.0;
bool timerStarted = false; bool timerStarted = false;
GameScreen currentScreen = MENU;
int selectedPairs = 3;
// 1. SPIELSPEZIFISCHE VARIABLEN HIER DEKLARIEREN (ohne Initialisierung)
std::vector<gamecube> cubes;
gamecube* first = nullptr;
gamecube* second = nullptr;
float flipSpeed = 5.0f; // Drehgeschwindigkeit
bool gameWon = false;
// Fenster und Kamera // Fenster und Kamera
InitWindow(800, 600, "3D Memory Game with Matrix3D Library"); InitWindow(800, 600, "3D Memory Game with Matrix3D Library");
@ -160,133 +217,151 @@ int main()
camera.fovy = 45.0f; camera.fovy = 45.0f;
camera.projection = CAMERA_PERSPECTIVE; 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 // Hauptspielschleife
// ----------------------------------------------------------- // -----------------------------------------------------------
while (!WindowShouldClose()) while (!WindowShouldClose())
{ {
if (!timerStarted) // -------------------------------------------------------
// UPDATE-LOGIK NACH ZUSTAND
// -------------------------------------------------------
switch (currentScreen)
{ {
startTime = GetTime(); case MENU:
timerStarted = true;
}
// Klick-Erkennung
if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
{
Vector2 mouse = GetMousePosition();
for (auto &c : cubes)
{ {
if (!c.IsFlipped() && !c.IsMatched()) // Menü-Abfrage: Auf Tastendruck warten
{ if (IsKeyPressed(KEY_THREE)) {
Vector2 screenPos = GetWorldToScreen({c.GetPosition().x, c.GetPosition().y, c.GetPosition().z}, camera); selectedPairs = 3; // 6 Würfel
SetupGame(cubes, selectedPairs);
if (fabs(mouse.x - screenPos.x) < 40 && fabs(mouse.y - screenPos.y) < 40) gameWon = false;
c.FlipForward(); first = second = nullptr;
currentScreen = GAMEPLAY;
timerStarted = false; // Timer-Reset
} else if (IsKeyPressed(KEY_SIX)) {
selectedPairs = 6; // 12 Würfel
SetupGame(cubes, selectedPairs);
gameWon = false;
first = second = nullptr;
currentScreen = GAMEPLAY;
timerStarted = false; // Timer-Reset
} }
break;
} }
case GAMEPLAY:
{
// Timer starten
if (!timerStarted)
{
startTime = GetTime();
timerStarted = true;
}
// 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);
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)
{
// Prüft, ob ALLE Würfel gematcht sind
gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
if (gameWon)
{
endTime = GetTime() - startTime;
}
}
break;
} // ENDE GAMEPLAY UPDATE
} }
// 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(); });
if (gameWon)
{
endTime = GetTime() - startTime;
}
}
// ----------------------------------------------------------- // -----------------------------------------------------------
// Zeichnen // ZEICHNEN NACH ZUSTAND
// ----------------------------------------------------------- // -----------------------------------------------------------
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
BeginMode3D(camera);
for (auto &c : cubes) switch (currentScreen)
c.Draw();
EndMode3D();
if (gameWon)
{ {
DrawText("Congrats! You found all pairs!", 150, 260, 30, DARKBLUE); case MENU:
{
// Menü-Darstellung
DrawText("3D MEMORY SPIEL", GetScreenWidth() / 2 - MeasureText("3D MEMORY SPIEL", 50) / 2, 80, 50, DARKGRAY);
DrawText("Waehlen Sie die Spielgroesse:", 50, 200, 25, BLACK);
DrawText("Druecken Sie [3] fuer 3 Paare (6 Wuerfel)", 50, 240, 20, BLUE);
DrawText("Druecken Sie [6] fuer 6 Paare (12 Wuerfel)", 50, 280, 20, BLUE);
break;
}
char buffer[64]; case GAMEPLAY:
sprintf(buffer, "Cleared in %.2f seconds", endTime); {
DrawText(buffer, 150, 300, 28, DARKGREEN); // Spiel-Darstellung
} BeginMode3D(camera);
else
{ for (auto &c : cubes)
DrawText("Flip 2 cubes - find matching pairs!", 10, 10, 20, DARKGRAY); c.Draw();
char liveBuf[64];
sprintf(liveBuf, "Time: %.2f", GetTime() - startTime); EndMode3D();
DrawText(liveBuf, 10, 40, 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);
}
break;
} // ENDE GAMEPLAY DRAW
} }
EndDrawing(); EndDrawing();
} }