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

JETZT NEU!

Browse Source
This commit is contained in:
Tomila Bakeeva 2025-12-15 12:14:07 +01:00
commit 0e9ee64c18
8 changed files with 227 additions and 202 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.

22
.gitignore vendored Normal file
View File

@ -0,0 +1,22 @@
# ===== Build =====
cmake-build-*/
build/
out/
# ===== IDE =====
.idea/
*.iml
# ===== OS =====
.DS_Store
# ===== Compiled =====
*.o
*.obj
*.a
*.so
*.dylib
*.exe
# ===== Logs =====
*.log

8
.idea/.gitignore generated vendored
View File

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

4
.idea/vcs.xml generated
View File

@ -1,4 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings" defaultProject="true" />
</project>

10
.vscode/launch.json vendored
View File

@ -1,10 +0,0 @@
{
// 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": [
]
}

10
src/gamecube.cpp
View File

@ -1,3 +1,4 @@
#include "raylib.h"
#include "gamecube.h"
gamecube::gamecube(const Vec3& pos, Color col)
@ -38,18 +39,17 @@ void gamecube::Draw() const
{
rlPushMatrix();
// Matrizen für Rotation und Translation erzeugen
auto matrix_a = Matrix3D::gameMatrix::translate({ 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');
// Matrizen multiplizieren (Translation * Rotation)
auto model = Matrix3D::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)

7
src/gamematrix.cpp
View File

@ -37,9 +37,9 @@ namespace Matrix3D
{
Mat4 result = identity();
result[0][3] = pos[0]; // x
result[1][3] = pos[1]; // y
result[2][3] = pos[2]; // z
result[0][3] = pos[0];
result[1][3] = pos[1];
result[2][3] = pos[2];
return result;
}
@ -93,5 +93,4 @@ namespace Matrix3D
return { res_hom[0], res_hom[1], res_hom[2] };
}
}

264
src/main.cpp
View File

@ -1,30 +1,70 @@
#include "gamecube.h"
#include <algorithm>
#include <ctime>
#include <vector>
#include "raylib.h"
enum GameScreen { MENU = 0, GAMEPLAY };
enum class GameState
static void SetupGame(std::vector<gamecube>& cubes, int pairs)
{
Idle, // kein Würfel offen, Eingabe erlaubt
OneFlipped, // ein Würfel offen
CheckingMatch, // zwei Würfel vollständig aufgeklappt, Vergleich läuft
LockInput // Würfel drehen gerade – Eingabe kurz blockiert
};
cubes.clear();
Color colors[] = { RED, GREEN, BLUE, YELLOW, ORANGE, PURPLE, WHITE, SKYBLUE };
std::vector<Vec3> positions;
const int count = pairs * 2;
int cols = 3;
int rows = 2;
if (count > 6) {
cols = 4;
rows = 3;
}
int index = 0;
for (int r = 0; r < rows && index < count; ++r) {
for (int c = 0; c < cols && index < count; ++c) {
positions.push_back({ (float)c * 2.0f - (cols - 1), 0.0f, (float)r * 2.0f - (rows - 1) });
index++;
}
}
std::vector<Color> colorPool;
colorPool.reserve(count);
for (int i = 0; i < pairs; i++) {
colorPool.push_back(colors[i]);
colorPool.push_back(colors[i]);
}
for (int i = (int)colorPool.size() - 1; i > 0; --i) {
int j = rand() % (i + 1);
std::swap(colorPool[i], colorPool[j]);
}
for (int i = 0; i < count; i++) {
cubes.emplace_back(positions[i], colorPool[i]);
}
}
// -----------------------------------------------------------
// 3D Memory Game – Hauptprogramm
// -----------------------------------------------------------
int main()
{
// Zufall initialisieren
srand(time(NULL));
srand((unsigned)time(NULL));
double startTime = 0.0;
double endTime = 0.0;
bool timerStarted = false;
GameScreen currentScreen = MENU;
int selectedPairs = 3;
std::vector<gamecube> cubes;
gamecube* first = nullptr;
gamecube* second = nullptr;
float flipSpeed = 5.0f;
bool gameWon = false;
// Fenster und Kamera
InitWindow(800, 600, "3D Memory Game with Matrix3D Library");
SetTargetFPS(60);
@ -35,165 +75,151 @@ int main()
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;
GameState state = GameState::Idle; // Start Zustand
// -----------------------------------------------------------
// Hauptspielschleife
// -----------------------------------------------------------
while (!WindowShouldClose())
{
if (!timerStarted)
switch (currentScreen)
{
case MENU:
{
if (IsKeyPressed(KEY_THREE)) {
selectedPairs = 3;
SetupGame(cubes, selectedPairs);
gameWon = false;
first = second = nullptr;
currentScreen = GAMEPLAY;
timerStarted = false;
}
else if (IsKeyPressed(KEY_SIX)) {
selectedPairs = 6;
SetupGame(cubes, selectedPairs);
gameWon = false;
first = second = nullptr;
currentScreen = GAMEPLAY;
timerStarted = false;
}
break;
}
case GAMEPLAY:
{
if (!timerStarted) {
startTime = GetTime();
timerStarted = true;
}
// Klick-Erkennung
if (!gameWon
&& state != GameState::LockInput
&& state != GameState::CheckingMatch
&& IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && (second == nullptr))
{
Vector2 mouse = GetMousePosition();
Ray ray = GetMouseRay(mouse, camera);
gamecube* hitCube = nullptr;
float bestDist = 1e9f;
for (auto& c : cubes)
{
if (!c.IsFlipped() && !c.IsMatched())
{
Vector2 screenPos = GetWorldToScreen({c.GetPosition().x, c.GetPosition().y, c.GetPosition().z}, camera);
if (c.IsMatched() || c.IsFlipped()) continue;
if (fabs(mouse.x - screenPos.x) < 40 && fabs(mouse.y - screenPos.y) < 40)
{
c.FlipForward();
auto p = c.GetPosition();
// ZUSTANDSUMSCHALTLOGIK
if (state == GameState::Idle)
BoundingBox box;
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 };
RayCollision col = GetRayCollisionBox(ray, box);
if (col.hit && col.distance < bestDist) {
bestDist = col.distance;
hitCube = &c;
}
}
if (hitCube)
{
// 1. Click
c.FlipForward();
first = &c;
state = GameState::OneFlipped;
break; // wichtig!!! Wir verlassen die Schleife :)
}
else if (state == GameState::OneFlipped)
{
// 2. Click
// Lass uns überprüfen, ob es NICHT derselbe Würfel ist.
if (&c != first)
{
c.FlipForward();
second = &c;
state = GameState::LockInput;
break; // wichtig!!! Wir verlassen die Schleife :)
}
}
if (!first) {
first = hitCube;
first->FlipForward();
}
else if (hitCube != first) {
second = hitCube;
second->FlipForward();
}
}
}
// Animation aller Würfel
bool animationBusy = false;
for (auto &c : cubes)
{
for (auto& c : cubes) {
c.Update(flipSpeed);
}
if (state == GameState::LockInput)
if (first && second && first->IsFlipped() && second->IsFlipped())
{
if (first && first->IsFlipped() && second && second->IsFlipped())
{
state = GameState::CheckingMatch;
}
}
Color col1 = first->GetColor();
Color col2 = second->GetColor();
// Matching-Logik
if (state == GameState::CheckingMatch && first && second)
{
if (first->GetColor().r == second->GetColor().r &&
first->GetColor().g == second->GetColor().g &&
first->GetColor().b == second->GetColor().b)
{
if (col1.r == col2.r && col1.g == col2.g && col1.b == col2.b) {
first->SetMatched(true);
second->SetMatched(true);
}
else
{
else {
first->FlipBackward();
second->FlipBackward();
}
first = second = nullptr;
state = GameState::Idle;
first = nullptr;
second = nullptr;
}
// Gewinnprüfung
if (!gameWon)
{
gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
if (gameWon)
{
gameWon = std::all_of(
cubes.begin(),
cubes.end(),
[](const gamecube& c) { return c.IsMatched(); }
);
if (gameWon) {
endTime = GetTime() - startTime;
}
}
// -----------------------------------------------------------
// Zeichnen
// -----------------------------------------------------------
break;
}
}
BeginDrawing();
ClearBackground(RAYWHITE);
switch (currentScreen)
{
case MENU:
{
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;
}
case GAMEPLAY:
{
BeginMode3D(camera);
for (auto &c : cubes)
c.Draw();
for (auto& c : cubes) c.Draw();
EndMode3D();
if (gameWon)
{
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
{
} 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;
}
}
EndDrawing();
}