fabuła gry

main.cpp

@@ -73,13 +73,22 @@ BOOL APIENTRY AboutDlgProc(HWND hDlg, UINT message, UINT wParam, LONG lParam);
 
 void SetDCPixelFormat(HDC hDC);
 
+static void platforma(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat xlen, GLfloat zlen);
+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;
 int monitormodecounter = 0;
 std::time_t monitormodehelper;
-
+short biezacy_wzor = 0;
-
+bool panoramic_view = 0;
 
 //Zmienne do ruchu ##############################################^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 FPSCounter fpsCounter;
@@ -109,12 +118,12 @@ bool keySPressed = false;
 bool keyAPressed = false;
 bool keyDPressed = false;
 
-float Foward = 0.0f;  // Pozycja łazika w przód/tył 
+float Foward   =  45.0f;  // Pozycja łazika w przód/tył 
-float Sides = 0.0f;    // Pozycja łazika w lewo/prawo
+float Sides    = -45.0f;  // Pozycja łazika w lewo/prawo
-float Rotation = 0.0f; // Rotacja łazika (w stopniach)
+float Rotation = 270.0f;  // Rotacja łazika (w stopniach)
 
 float CameraHeight = 50.0f;  // Wysokość kamery
-float MoveSpeed = 1.0f;      // Prędkość poruszania się
+float MoveSpeed = 0.5f;      // Prędkość poruszania się
 
 
 float velocity = 0.0f;       // Aktualna prędkość łazika
@@ -122,13 +131,13 @@ float rotationVelocity = 0.0f; // Prędkość obrotu łazika
 
 
 const float friction = 0.1f; // Współczynnik tarcia (μ)
-const float maxSpeed = 5.0f; // Maksymalna prędkość łazika
+const float maxSpeed = 2.0f; // Maksymalna prędkość łazika
 const float acceleration = 0.2f;
 
 
-const float rotationAcceleration = 0.075f; // Przyspieszenie obrotu
+float rotationAcceleration = 0.075f; // Przyspieszenie obrotu
-const float rotationFriction = 0.1f; // Współczynnik tarcia obrotu
+float rotationFriction = 0.1f; // Współczynnik tarcia obrotu
-const float maxRotationSpeed = 0.7f; // Maksymalna prędkość obrotu
+float maxRotationSpeed = 0.5f; // Maksymalna prędkość obrotu
 
 // Struktura do reprezentacji płotu
 struct Plot {
@@ -315,12 +324,239 @@ static void UpdateRover(const std::vector<Plot>& fences) {
 
 
 std::vector<Plot> fences = {
-	{-550.0f, 3.0f,   50.0f, 1310.0f, 4.0f, 0}, // 0 - pionowo
+	{  450.0f, 3.0f,   -90.0f, 900.0f, 4.0f, 1}, // 1 - poziomo
-	{  50.0f, 3.0f, -600.0f, 1200.0f, 4.0f, 1}, // 1 - poziomo
+	{    0.0f, 3.0f,   405.0f, 990.0f, 4.0f, 0}, // 0 - pionowo
-	{ 650.0f, 3.0f,   50.0f, 1310.0f, 4.0f, 0}, // 0 - pionowo
+	{  450.0f, 3.0f, 10*90.0f, 900.0f, 4.0f, 1}, // 1 - poziomo
-	{  50.0f, 3.0f,  695.0f, 1200.0f, 4.0f, 1}  // 1 - poziomo
+	{10*90.0f, 3.0f,   405.0f, 990.0f, 4.0f, 0}  // 0 - pionowo
 };
 
+std::vector<std::vector<bool>> wzory = {
+
+	// GK
+	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 1, 1, 1, 0, 1, 0, 0, 1, 0,
+	 0, 1, 0, 0, 0, 1, 0, 1, 1, 0,
+	 1, 1, 0, 0, 0, 1, 1, 1, 0, 0,
+	 1, 0, 0, 0, 0, 1, 1, 0, 0, 0,
+	 1, 0, 1, 1, 0, 1, 1, 0, 0, 0,
+	 1, 0, 0, 1, 1, 1, 1, 1, 0, 0,
+	 1, 1, 0, 0, 1, 1, 0, 1, 1, 0,
+	 0, 1, 1, 1, 1, 1, 0, 0, 1, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+
+	// Ślimak
+	{0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
+	 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 1, 0, 0, 1, 1, 1, 1, 1, 1, 0,
+	 1, 0, 1, 1, 0, 0, 0, 0, 1, 0,
+	 1, 0, 1, 0, 1, 0, 0, 0, 1, 0,
+	 1, 0, 1, 1, 1, 0, 0, 0, 1, 0,
+	 1, 0, 0, 0, 0, 1, 1, 1, 1, 0,
+	 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+
+	// Sygnał TTL
+	{0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
+	 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
+	 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
+	 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+
+	// Okrąg
+	{0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
+	 0, 1, 1, 0, 0, 0, 1, 1, 1, 0,
+	 0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
+	 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
+	 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+	 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
+	 0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
+	 0, 1, 1, 0, 0, 0, 0, 1, 1, 0,
+	 0, 0, 1, 1, 1, 0, 0, 1, 0, 0,
+	 0, 0, 0, 0, 1, 1, 1, 1, 1, 1},
+
+	// Kwadrat
+	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+	 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+	 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+
+	// ABACABA
+	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
+	 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
+	 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+	 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+	 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+
+	 // Paski
+	 {1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
+	  1, 0, 1, 1, 1, 0, 1, 0, 1, 0,
+	  1, 0, 1, 0, 1, 1, 1, 0, 1, 0,
+	  1, 0, 1, 0, 1, 0, 1, 1, 1, 0,
+	  1, 0, 1, 0, 1, 0, 1, 0, 1, 1,
+	  1, 0, 1, 0, 1, 0, 1, 0, 1, 1,
+	  1, 0, 1, 0, 1, 0, 1, 1, 1, 0,
+	  1, 0, 1, 0, 1, 1, 1, 0, 1, 0,
+	  1, 0, 1, 1, 1, 0, 1, 0, 1, 0,
+	  1, 1, 1, 0, 1, 0, 1, 0, 1, 0},
+
+	// Puste pole
+	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+};
+
+std::vector<unsigned short> siatka = {
+
+	// Możliwe stany pól siatki:
+	// - 0 - niezamalowana, nie do zamalowania (zielony)
+	// - 1 - niezamalowana, do zamalowania (złoty)
+	// - 2 - zamalowana,    nie do zamalowania (czerwony)
+	// - 3 - zamalowana,    do zamalowania (jasnozielony)
+
+	// 1. bit mówi o tym, czy jest do zamalowania
+	// 2. bit mówi o tym, czy jest zamalowana
+
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+
+};
+
+void sprawdzPostepGry() {
+	unsigned short zgodne_pola = 0;
+	for (int i = 0; i < 10; i++) {
+		for (int j = 0; j < 10; j++) {
+			std::cout << "zgp: " << zgodne_pola << "\n";
+			unsigned short pole_w_siatce = siatka[10*i + (9 - j)];
+			bool pole_we_wzorach = wzory[biezacy_wzor][10*i + (9 - j)];
+			if (pole_w_siatce == 0 && pole_we_wzorach == 0) zgodne_pola++;
+			else if (pole_w_siatce == 3 && pole_we_wzorach == 1) zgodne_pola++;
+			else {
+				std::cout << "dla i=" << i << " j=" << j << " otrzymano p_w_s " << pole_w_siatce << " a spodziewano sie p_w_w: " << pole_we_wzorach << "\n";
+				return;
+			}
+		}
+	}
+	if (zgodne_pola == 100) {
+		biezacy_wzor = (biezacy_wzor + 1) % (wzory.size() + 1);
+		nadpiszNowaSiatke(biezacy_wzor);
+	} else {
+		std::cout << "zgodne_pola: " << zgodne_pola << "\n";
+	}
+}
+
+void ustalPozycjeGracza(GLfloat gracz_x, GLfloat gracz_z, short &grid_x, short &grid_z) {
+	grid_x = static_cast<int>(gracz_x) / 90;
+	grid_z = static_cast<int>(gracz_z) / 90;
+
+	// zapobiega rysowaniu ze "spawna"
+	if (gracz_x < 0 && gracz_x > -90) grid_x = -1; // ten przypadek dotyczy tylko noclipa
+	if (gracz_z < 0 && gracz_z > -90) grid_z = -1;
+}
+
+void ustawSiatkeNaWzorNieNadpisujacPostepu() {
+	for (int i = 0; i < 10; i++) {
+		for (int j = 0; j < 10; j++) {
+			bool ma_byc_zamalowana = wzory[biezacy_wzor][10*i + (10 - j)];
+			if (ma_byc_zamalowana) siatka[10*i + (10 - j)] |= 1;
+			else siatka[10*i + (10 - j)] = siatka[10*i + (10 - j)] - siatka[10*i + (10 - j)] % 2;
+		}
+	}
+}
+
+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++) {
+			siatka[10*i + (10 - j)] = static_cast<unsigned short>(wzory[biezacy_wzor][10*i + (10 - j)]);
+		}
+	}
+}
+
+void tworzKratke(unsigned int grid_x, unsigned int grid_z, unsigned short grid_value) {
+
+	// https://rgbcolorpicker.com/0-1
+	switch (grid_value) {
+
+		case 0:
+			// niezamalowana, nie do zamalowania (zielony)
+			glColor3d(0.031, 0.51, 0.094);
+			break;
+
+		case 1:
+			// niezamalowana, do zamalowania (złoty)
+			glColor3d(0.7, 0.5, 0.259);
+			break;
+
+		case 2:
+			// zamalowana, nie do zamalowania (czerwony)
+			glColor3d(1, 0.122, 0);
+			break;
+
+		case 3:
+			// zamalowana, do zamalowania (biały)
+			glColor3d(1, 1, 1);
+			break;
+
+	}
+
+	platforma(45.0f + grid_x * 90.0f, 0.0f, 45.0f + grid_z * 90.0f, 45.0f, 45.0f);
+
+}
+
+void tworzKratkiZSiatki() {
+	for (int i = 0; i < 10; i++) {
+		// Aby nie musieć rysować wzorów w odbiciu
+		// lustrzanym, musimy tutaj przyjąć inną sekwencję
+		for (int j = 0; j < 10; j++) {
+			tworzKratke(i, j, siatka[10*i + (9 - j)]);
+		}
+	}
+}
+
+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;
+	// jeżeli coś się zmieniło
+	if (siatka[10*grid_x + (9 - grid_z)] != a) {
+		sprawdzPostepGry();
+	}
+}
+
 // Change viewing volume and viewport. Called when window is resized
 void static ChangeSize(GLsizei w, GLsizei h) {
 	GLfloat nRange = 100.0f;
@@ -499,14 +735,14 @@ static void skrzynka(GLfloat k) {
 }
 
 static void platforma(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat xlen, GLfloat zlen) {
-	glColor3d(0.729, 0.91, 0.51); // jasnozielony, dla grass02.bmp
+	// glColor3d(0.729, 0.91, 0.51); // jasnozielony, dla grass02.bmp
 
 	glEnable(GL_TEXTURE_2D);
 	glBindTexture(GL_TEXTURE_2D, texture[1]); // Wybieramy teksturę
 
 	// Ustawienie powtarzania tekstury
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Powtarzanie w kierunku S
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); // Powtarzanie w kierunku S
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Powtarzanie w kierunku T
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); // Powtarzanie w kierunku T
 
 	glBegin(GL_QUADS);
 	// Powtarzające się współrzędne tekstury (np. *5, aby powtórzyła się 5 razy)
@@ -897,11 +1133,13 @@ static void SetupRC() {
 
 
 void static RenderScene(void) {
+
+	// PS: to nie zadziała, bo okno nie jest tworzone przez glfw
 	// Ustawienie liczby próbek dla antyaliasingu
-	glfwWindowHint(GLFW_SAMPLES, 16);  // 4x MSAA (Wielokrotne próbkowanie)
+	// glfwWindowHint(GLFW_SAMPLES, 16);  // 4x MSAA (Wielokrotne próbkowanie)
 
 	// Włączenie antyaliasingu (MSAA)
-	glEnable(GL_MULTISAMPLE);
+	//glEnable(GL_MULTISAMPLE);
 
 	// Przywrócenie macierzy modelu i ustawienie obrotów
 	glPushMatrix();
@@ -922,19 +1160,36 @@ void static RenderScene(void) {
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 	// Przywrócenie macierzy widoku
-	gluLookAt(
+	if (panoramic_view) {
-		Foward - 50.0f * sin((Rotation + 180.0f) * GL_PI / 180.0f),      // Pozycja kamery
+		maxRotationSpeed = 1.0f;
-		CameraHeight/4,                                                  // Wysokość kamery
+		rotationFriction = 0.5f;
-		Sides - 50.0f * cos((Rotation + 180.0f) * GL_PI / 180.0f),       // Kamera wzdłuż osi X i Z
+		gluLookAt(
-		Foward, 0.0f, Sides,                                             // Punkt patrzenia (łazik)
+			Foward,                                                          // Pozycja kamery
-		0.0f, 1.0f, 0.0f                                                 // Wektor "góry"
+			123,                                                             // Wysokość kamery, nie ma znaczenia bo nie mamy perspektywy
-	);
+			Sides - 1.0f,                                                    // Kamera wzdłuż osi X i Z, z jakiegoś powodu działa po "- 1.0f"
+			Foward, 0.0f, Sides,                                             // Punkt patrzenia (łazik)
+			0.0f, 1.0f, 0.0f                                                 // Wektor "góry"
+		);
+	} else {
+		maxRotationSpeed = 0.5f;
+		rotationFriction = 0.1f;
+		gluLookAt(
+			Foward - 50.0f * sin((Rotation + 180.0f) * GL_PI / 180.0f),      // Pozycja kamery
+			CameraHeight / 4,                                                // Wysokość kamery
+			Sides - 50.0f * cos((Rotation + 180.0f) * GL_PI / 180.0f),       // Kamera wzdłuż osi X i Z
+			Foward, 0.0f, Sides,                                             // Punkt patrzenia (łazik)
+			0.0f, 1.0f, 0.0f                                                 // Wektor "góry"
+		);
+	}
+	
 
 	// Rysowanie mapy
 	glPushMatrix();
 	glColor3f(0.0, 1.0, 0.0);  // Zielony kolor
-	mapa.draw();
+	// mapa.draw(); // nie rysuj mapy/terenu .obj
-	platforma(50.0f, 0.0f, 45.0f, 600.0f, 650.0f);
+	// 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);
 	glPopMatrix();
 
 	// Rysowanie łazika
@@ -942,18 +1197,28 @@ 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();
 	UpdateRover(fences);
 	fpsCounter.update();
 	glPopMatrix();
 
+	// std::cout << "X: " << Foward << " Z: " << Sides << " Rotation: " << Rotation << "\n";
+
 	// Rysowanie innych obiektów
-	plot(-550.0f, 3.0f,   50.0f, 1310.0f, 4.0f, 0); // 0 - pionowo
+	plot(  450.0f, 3.0f,    -90.0f, 900.0f, 4.0f, 1); // 1 - poziomo
-	plot(  50.0f, 3.0f, -600.0f, 1200.0f, 4.0f, 1); // 1 - poziomo
+	plot(    0.0f, 3.0f,    405.0f, 990.0f, 4.0f, 0); // 0 - pionowo
-	plot( 650.0f, 3.0f,   50.0f, 1310.0f, 4.0f, 0);
+	plot(  450.0f, 3.0f,  10*90.0f, 900.0f, 4.0f, 1); // 1 - poziomo
-	plot(  50.0f, 3.0f,  695.0f, 1200.0f, 4.0f, 1);
+	plot(10*90.0f, 3.0f,    405.0f, 990.0f, 4.0f, 0); // 0 - pionowo
-	stodola(10.0f, 0.0f, 2.0f, 40.0f);
+	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";
+	ustawSiatkeNaWzorNieNadpisujacPostepu();
+	tworzKratkiZSiatki();
+	aktualizujBiezacaKratke(grid_x, grid_z);
 
 	// Zamiana buforów (double buffering)
 	// glfwSwapBuffers(window); // Przełączenie buforów
@@ -964,6 +1229,7 @@ void static RenderScene(void) {
 
 	// Wymuszenie wykonania wszystkich rysunków
 	glFlush();
+
 }
 
 
@@ -1393,6 +1659,18 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 				// 	if (!monitormode) timestampedCout("Wylaczono tryb monitorowania wydajnosci.");
 				// 	break;
 
+				case 116: // F5 włącza widok panoramiczny
+					panoramic_view = !panoramic_view;
+					break;
+
+				case 16: // Shift również
+					panoramic_view = !panoramic_view;
+					break;
+
+				case 8: // Backspace czyści postęp
+					nadpiszNowaSiatke(biezacy_wzor);
+					break;
+
 				default:
 					timestampedCout("Nacisnieto nierozpoznany klawisz: " << (int)wParam);
 			}