poprawiona czytelność kodu

fabula.cpp

@@ -171,7 +171,6 @@ void ustawSiatkeNaWzorNieNadpisujacPostepu() {
 }
 
 void nadpiszNowaSiatke(short nowy_wzor) {
-	std::cout << "Przepisz zawartosc siatki!\n";
 	biezacy_wzor = nowy_wzor;
 	for (int i = 0; i < 10; i++) {
 		for (int j = 0; j < 10; j++) {
@@ -215,6 +214,7 @@ void tworzKratkiZSiatki() {
 	for (int i = 0; i < 10; i++) {
 		// Aby nie musieć rysować wzorów w odbiciu
 		// lustrzanym, musimy tutaj przyjąć inną sekwencję
+		// (dlatego rysujemy od prawej do lewej (9 do 0))
 		for (int j = 0; j < 10; j++) {
 			tworzKratke(i, j, siatka[10*i + (9 - j)]);
 		}
@@ -223,10 +223,13 @@ void tworzKratkiZSiatki() {
 
 void aktualizujBiezacaKratke(short grid_x, short grid_z) {
 	if (grid_x < 0 || grid_z < 0) return;
-	unsigned short a = siatka[10*grid_x + (9 - grid_z)];
+
-	siatka[10*grid_x + (9 - grid_z)] |= 2;
+	unsigned short poprzednia_wartosc = siatka[10*grid_x + (9 - grid_z)];
-	// jeżeli coś się zmieniło
+	siatka[10*grid_x + (9 - grid_z)] |= 2; // zaznacz pole jako zamalowane
-	if (siatka[10*grid_x + (9 - grid_z)] != a) {
+	unsigned short       nowa_wartosc = siatka[10*grid_x + (9 - grid_z)];
+	
+	// Jeżeli któreś z pól zostało zaktualizowane, sprawdź postęp gry
+	if (poprzednia_wartosc != nowa_wartosc) {
 		sprawdzPostepGry();
 	}
 }

main.cpp

@@ -75,14 +75,6 @@ BOOL APIENTRY AboutDlgProc(HWND hDlg, UINT message, UINT wParam, LONG lParam);
 
 void SetDCPixelFormat(HDC hDC);
 
-void sprawdzPostepGry();
-void ustalPozycjeGracza(GLfloat gracz_x, GLfloat gracz_z, short &grid_x, short &grid_z);
-void ustawSiatkeNaWzorNieNadpisujacPostepu();
-void nadpiszNowaSiatke(short nowy_wzor);
-void tworzKratke(unsigned int grid_x, unsigned int grid_z, unsigned short grid_value);
-void tworzKratkiZSiatki();
-void aktualizujBiezacaKratke(short grid_x, short grid_z);
-
 int polygonmode = 0;
 std::time_t lastTime = std::time(nullptr);
 int monitormode = 1;
@@ -150,7 +142,6 @@ struct Plot {
 	bool mod_x;       // 0 - płot pionowy, 1 - płot poziomy
 };
 
-// Funkcja sprawdzająca kolizję z płotem
 // Funkcja sprawdzająca kolizję z płotem, uwzględniając wymiary łazika
 static bool CheckFenceCollision(float roverXMin, float roverXMax, float roverZMin, float roverZMax, const Plot& plot) {
 	if (plot.mod_x == 0) { // Płot pionowy (równoległy do osi Z)
@@ -164,8 +155,9 @@ static bool CheckFenceCollision(float roverXMin, float roverXMax, float roverZMi
 			roverZMax >= zMin && roverZMin <= zMax) { // Kolizja w osi Z
 			return true;
 		}
-	}
+	} else {
-	else { // Płot poziomy (równoległy do osi X)
+
+		// Płot poziomy (równoległy do osi X)
 		float xMin = plot.xc -   plot.length / 2.0f;
 		float xMax = plot.xc +   plot.length / 2.0f;
 		float zMin = plot.zc - plot.gruboscY / 2.0f;
@@ -182,57 +174,77 @@ static bool CheckFenceCollision(float roverXMin, float roverXMax, float roverZMi
 
 // Funkcja ogólna do sprawdzania kolizji ze wszystkimi płotami
 static bool CheckAllFencesCollision(float roverXMin, float roverXMax, float roverZMin, float roverZMax, const std::vector<Plot>& fences) {
-	for (const auto& fence : fences) {
+	for (const auto& fence: fences) {
 		if (CheckFenceCollision(roverXMin, roverXMax, roverZMin, roverZMax, fence)) {
-			return true; // Kolizja wykryta z którymś płotem
+			// Kolizja wykryta z którymś płotem
+			return true;
 		}
 	}
 	return false; // Brak kolizji
 }
 
 static void UpdateRover(const std::vector<Plot>& fences) {
-    // Przyspieszanie w przód
+
 	if (keyWPressed) {
+
+		// Przyspieszanie w przód
 		velocity += acceleration;
 		if (velocity > maxSpeed) velocity = maxSpeed;
-    }
+
+	} else if (keySPressed) {
+
 		// Przyspieszanie w tył
-    else if (keySPressed) {
 		velocity -= acceleration;
 		if (velocity < -maxSpeed) velocity = -maxSpeed;
-    }
+
+	} else {
+
 		// Hamowanie (wytracanie prędkości z powodu tarcia)
-    else {
 		if (velocity > 0) {
+
 			velocity -= friction;
 			if (velocity < 0) velocity = 0;
-        }
+
-        else if (velocity < 0) {
+		} else if (velocity < 0) {
+
 			velocity += friction;
 			if (velocity > 0) velocity = 0;
+
 		}
+
 	}
 
 	// Obracanie (rotacja z driftowaniem)
 	if (keyAPressed) {
+
 		rotationVelocity += rotationAcceleration;
 		if (rotationVelocity > maxRotationSpeed) rotationVelocity = maxRotationSpeed;
-    }
+
-    else if (keyDPressed) {
+	} else if (keyDPressed) {
+
 		rotationVelocity -= rotationAcceleration;
 		if (rotationVelocity < -maxRotationSpeed) rotationVelocity = -maxRotationSpeed;
-    }
+
-    else {
+	} else {
-        // Jeśli żadna z klawiszy A/D nie jest wciśnięta, to stopniowo spowalniamy rotację (drift)
+
-        float driftFactor = 0.1f;  // Mniejsza wartość = dłuższy drift
+		// Jeśli żaden z klawiszy A/D nie jest wciśnięty,
+		// to stopniowo spowalniamy rotację (drift)
+		
+		// Mniejsza wartość = dłuższy drift
+		float driftFactor = 0.1f;  
+
 		if (rotationVelocity > 0) {
+
 			rotationVelocity -= rotationFriction * driftFactor;
 			if (rotationVelocity < 0) rotationVelocity = 0;
-        }
+
-        else if (rotationVelocity < 0) {
+		} else if (rotationVelocity < 0) {
+
 			rotationVelocity += rotationFriction * driftFactor;
 			if (rotationVelocity > 0) rotationVelocity = 0;
+
 		}
+
 	}
 
 	// Wyliczenie nowej pozycji na podstawie prędkości
@@ -251,13 +263,13 @@ static void UpdateRover(const std::vector<Plot>& fences) {
 	float roverZMax = newFoward + roverHalfLengthZ;
 
 	// Sprawdzanie kolizji przed aktualizacją pozycji
-    if (!Kolizja == true) {
+	if (!Kolizja) {
+
 		if (CheckAllFencesCollision(roverZMin, roverZMax, roverXMin, roverXMax, fences)) {
 			// Jeśli jest kolizja, zatrzymujemy łazik
+			// cout << "Kolizja podczas ruchu!\n";
 			velocity = 0.0f;
-            //cout << "Kolizja podczas ruchu\n";
+		} else {
-        }
-        else {
 			// Jeśli brak kolizji, aktualizujemy pozycję
 			Sides = newSides;
 			Foward = newFoward;
@@ -276,40 +288,39 @@ static void UpdateRover(const std::vector<Plot>& fences) {
 			corners[2] = {Sides - roverHalfWidthX, Foward + roverHalfLengthZ}; // Lewy górny
 			corners[3] = {Sides + roverHalfWidthX, Foward + roverHalfLengthZ}; // Prawy górny
 			bool collisionDetected = false;
+
 			// Obracamy wszystkie narożniki
-			for (auto& corner : corners) {
+			for (auto& corner: corners) {
 				float x = corner.first;
 				float z = corner.second;
 
 				corner.first  =  Sides + (x - Sides) * cos(radNewRotation) - (z - Foward) * sin(radNewRotation);
 				corner.second = Foward + (x - Sides) * sin(radNewRotation) + (z - Foward) * cos(radNewRotation);
 
-
 				// Sprawdzamy kolizję na podstawie obróconych narożników
-				
+				if (CheckAllFencesCollision( corner.first,  corner.first, corner.second, corner.second, fences)) {
-
-				if (CheckAllFencesCollision(corner.first, corner.first, corner.second, corner.second, fences)) {
 					collisionDetected = true;
 					break;
 				}
-				if (CheckAllFencesCollision( corner.second, corner.second, corner.first, corner.first, fences)) {
+				if (CheckAllFencesCollision(corner.second, corner.second,  corner.first,  corner.first, fences)) {
 					collisionDetected = true;
 					break;
 				}
 			}
 
 			if (collisionDetected) {
+				//cout << "Kolizja podczas obrotu!\n";
 				rotationVelocity = 0.0f; // Zatrzymujemy obrót
-                //cout << "Kolizja podczas obrotu\n";
 			} else {
 				// Aktualizujemy rotację, jeśli nie ma kolizji
 				Rotation = newRotation;
 				if (Rotation >= 360.0f) Rotation -= 360.0f;
 				if (Rotation <    0.0f) Rotation += 360.0f;
 			}
+
 		}
-    }
+
-    else {
+	} else {
 		// Jeśli kolizje są wyłączone, aktualizujemy wszystko bez sprawdzania
 		Sides     = newSides;
 		Foward    = newFoward;
@@ -320,10 +331,6 @@ static void UpdateRover(const std::vector<Plot>& fences) {
 }
 
 
-
-
-
-
 std::vector<Plot> fences = {
 	{  450.0f, 3.0f,   -90.0f, 900.0f, 4.0f, 1}, // 1 - poziomo
 	{    0.0f, 3.0f,   405.0f, 990.0f, 4.0f, 0}, // 0 - pionowo
@@ -438,15 +445,15 @@ void SetDCPixelFormat(HDC hDC) {
 		PFD_DOUBLEBUFFER,                       // Double buffered
 		PFD_TYPE_RGBA,                          // RGBA Color mode
 		24,                                     // Want 24bit color 
-		0,0,0,0,0,0,                            // Not used to select mode
+		0, 0, 0, 0, 0, 0,                       // Not used to select mode
-		0,0,                                    // Not used to select mode
+		0, 0,                                   // Not used to select mode
-		0,0,0,0,0,                              // Not used to select mode
+		0, 0, 0, 0, 0,                          // Not used to select mode
 		32,                                     // Size of depth buffer
 		0,                                      // Not used to select mode
 		0,                                      // Not used to select mode
 		PFD_MAIN_PLANE,                         // Draw in main plane
 		0,                                      // Not used to select mode
-		0,0,0 };                                // Not used to select mode
+		0, 0, 0 };                              // Not used to select mode
 
 	// Choose a pixel format that best matches that described in pfd
 	nPixelFormat = ChoosePixelFormat(hDC, &pfd);
@@ -461,16 +468,16 @@ plane mapa( 0.0f, 0.0f, 0.0f, "res/models/mapka3_nofence_noplatform.obj");
 
 static void SetupRC() {
 	// Light values and coordinates
-	GLfloat ambientLight[] = { 0.3f, 0.3f, 0.3f, 1.0f };
+	GLfloat ambientLight[] = {0.3f, 0.3f, 0.3f, 1.0f};
-	GLfloat diffuseLight[] = { 0.7f, 0.7f, 0.7f, 1.0f };
+	GLfloat diffuseLight[] = {0.7f, 0.7f, 0.7f, 1.0f};
-	GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
+	GLfloat specular[]     = {1.0f, 1.0f, 1.0f, 1.0f};
-	GLfloat specref[] = { 1.0f, 1.0f, 1.0f, 1.0f };
+	GLfloat specref[]      = {1.0f, 1.0f, 1.0f, 1.0f};
 
 	// Multiple light positions (for light coming from all sides)
-	GLfloat lightPos1[] = { 50.0f, -100.0f, 50.0f, 1.0f };  // Light 0 position
+	GLfloat lightPos1[] = { 50.0f, -100.0f,  50.0f, 1.0f}; // Light 0 position
-	GLfloat lightPos2[] = { -50.0f, -100.0f, 50.0f, 1.0f }; // Light 1 position
+	GLfloat lightPos2[] = {-50.0f, -100.0f,  50.0f, 1.0f}; // Light 1 position
-	GLfloat lightPos3[] = { 50.0f, -100.0f, -50.0f, 1.0f }; // Light 2 position
+	GLfloat lightPos3[] = { 50.0f, -100.0f, -50.0f, 1.0f}; // Light 2 position
-	GLfloat lightPos4[] = { -50.0f, -100.0f, -50.0f, 1.0f }; // Light 3 position
+	GLfloat lightPos4[] = {-50.0f, -100.0f, -50.0f, 1.0f}; // Light 3 position
 
 	glEnable(GL_DEPTH_TEST);    // Hidden surface removal
 	glFrontFace(GL_CCW);        // Counter clockwise polygons face out
@@ -576,8 +583,9 @@ void static RenderScene(void) {
 	// Czyszczenie ekranu przed rysowaniem
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-	// Przywrócenie macierzy widoku
+	// Widok panoramiczny (SHIFT/F5)
 	if (panoramic_view) {
+		// Zwiększ prędkość obrotu oraz tarcie
 		maxRotationSpeed = 1.0f;
 		rotationFriction = 0.5f;
 		gluLookAt(
@@ -588,6 +596,7 @@ void static RenderScene(void) {
 			0.0f, 1.0f, 0.0f                                                 // Wektor "góry"
 		);
 	} else {
+		// Ustaw tarcie i prędkość obrotu na domyślną wartość
 		maxRotationSpeed = 0.5f;
 		rotationFriction = 0.1f;
 		gluLookAt(
@@ -602,8 +611,9 @@ void static RenderScene(void) {
 
 	// Rysowanie mapy
 	glPushMatrix();
-	glColor3f(0.0, 1.0, 0.0);  // Zielony kolor
+	// glColor3f(0.0, 1.0, 0.0);  // Zielony kolor
 	// mapa.draw(); // nie rysuj mapy/terenu .obj
+
 	// Platforma niebędąca częścią siatki:
 	glColor3d(0.031, 0.51, 0.094); // ciemnozielony
 	platforma(450.0f, 0.0f, -45.0f, 450.0f, 45.0f);
@@ -614,7 +624,7 @@ void static RenderScene(void) {
 	glTranslatef(Foward, 0.0f, Sides);      // Translacja łazika
 	glRotatef(Rotation, 0.0f, 1.0f, 0.0f);  // Obrót łazika
 	glColor3f(1.0, 0.0, 0.0);               // Czerwony kolor dla łazika
-	user.draw();
+	user.draw();                            // Rysuj łazik z pomocą lazik.cpp
 	UpdateRover(fences);
 	fpsCounter.update();
 	glPopMatrix();
@@ -622,6 +632,7 @@ void static RenderScene(void) {
 	// std::cout << "X: " << Foward << " Z: " << Sides << " Rotation: " << Rotation << "\n";
 
 	// Rysowanie innych obiektów
+	// 1 pole siatki = 90x90m
 	plot(  450.0f, 3.0f,    -90.0f, 900.0f, 4.0f, 1); // 1 - poziomo
 	plot(    0.0f, 3.0f,    405.0f, 990.0f, 4.0f, 0); // 0 - pionowo
 	plot(  450.0f, 3.0f,  10*90.0f, 900.0f, 4.0f, 1); // 1 - poziomo
@@ -629,7 +640,6 @@ void static RenderScene(void) {
 	stodola(45.0f, 0.0f, -45.0f, 70.0f);
 
 	// Mechanika gry
-	// 1 pole siatki = 90x90m
 	short grid_x, grid_z;
 	ustalPozycjeGracza(Foward, Sides, grid_x, grid_z);
 	// std::cout << "grid_X: " << grid_x << " grid_Z: " << grid_z << " status: " << siatka[10*grid_x + (9 - grid_z)] << "\n";
@@ -721,7 +731,9 @@ HPALETTE static GetOpenGLPalette(HDC hDC) {
 	// Return the handle to the new palette
 	return hRetPal;
 }
+
 void static CreateConsole() {
+
 	// Tworzenie nowej konsoli
 	if (AllocConsole()) {
 		// Przekierowanie standardowych strumieni do konsoli
@@ -731,18 +743,19 @@ void static CreateConsole() {
 		freopen_s(&conin, "conin$", "r", stdin);
 		freopen_s(&conout, "conout$", "w", stdout);
 		freopen_s(&conerr, "conout$", "w", stderr);
-	}
+	} else {
-	else {
 		MessageBox(NULL, "Nie udalo sie utworzyc konsoli.", "Blad", MB_OK | MB_ICONERROR);
 	}
+
 }
-	int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
+
+int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
+
 	CreateConsole();
 	MSG             msg;   // Windows message structure
 	WNDCLASS        wc{};  // Windows class structure
 	HWND            hWnd;  // Storeage for window handle
 
-
 	hInstance = hInst;
 		
 	// Register Window style
@@ -786,9 +799,8 @@ void static CreateConsole() {
 
 	const WORD ID_TIMER = 1;
 	SetTimer(hWnd, ID_TIMER, 100, NULL);
+
 	// Display the window
-
-
 	ShowWindow(hWnd, SW_SHOW);
 	UpdateWindow(hWnd);
 
@@ -799,7 +811,7 @@ void static CreateConsole() {
 	}
 
 	return msg.wParam;
-	}
+}
 
 
 // Window procedure, handles all messages for this program
@@ -811,6 +823,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 	switch (message) {
 		// Window creation, setup for OpenGL
 		case WM_CREATE:
+
 			// Store the device context
 			hDC = GetDC(hWnd);
 
@@ -903,8 +916,8 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 
 		// Window is being destroyed, cleanup
 		case WM_DESTROY:
-			user.unload();
 
+			user.unload();
 			//glDeleteProgram(programID);
 			//glDeleteVertexArrays(1, &VertexArrayID);
 
@@ -922,6 +935,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 
 		// Window is resized.
 		case WM_SIZE:
+
 			// Call our function which modifies the clipping
 			// volume and viewport
 			ChangeSize(LOWORD(lParam), HIWORD(lParam));
@@ -939,13 +953,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 			// Validate the newly painted client area
 			if (!monitormode) ValidateRect(hWnd, NULL);
 			else InvalidateRect(hWnd, NULL, FALSE);
-			//break;
+			break;
-
-			// Limit FPS
-			// Uaktualniaj FPS
-			// Ogranicz FPS
-
-			
 
 		case WM_QUERYNEWPALETTE:
 			// If the palette was created.
@@ -982,8 +990,10 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 				// Remap the current colors to the newly realized palette
 				UpdateColors(hDC);
 				return 0;
+
 			}
 			break;
+
 		case WM_KEYUP:
 
 			switch (wParam) {