OK

main.cpp

@@ -75,6 +75,159 @@ int monitormode = 0;
 int monitormodecounter = 0;
 std::time_t monitormodehelper;
 
+
+
+//Zmienne do ruchu ##############################################^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+FPSCounter fpsCounter;
+static const int targetFPS = 144; // Celowany FPS
+//Fps counter
+void LimitFPS(int targetFPS) {
+	static auto lastTime = std::chrono::high_resolution_clock::now();
+	auto currentTime = std::chrono::high_resolution_clock::now();
+	std::chrono::duration<double> elapsed = currentTime - lastTime;
+
+	// Jeśli upłynęło za mało czasu, aby osiągnąć target FPS, czekamy
+	double frameTime = 1.0 / targetFPS; // Czas na jedną klatkę w sekundach
+	if (elapsed.count() < frameTime) {
+		std::this_thread::sleep_for(std::chrono::duration<double>(frameTime - elapsed.count()));
+	}
+
+	lastTime = std::chrono::high_resolution_clock::now();
+}
+bool keyWPressed = false;
+bool keySPressed = false;
+bool keyAPressed = false;
+bool keyDPressed = false;
+
+float Foward = 0.0f;  // Pozycja łazika w przód/tył 
+float Sides = 0.0f;    // Pozycja łazika w lewo/prawo
+float Rotation = 0.0f; // Rotacja łazika (w stopniach)
+
+float CameraHeight = 50.0f;  // Wysokość kamery
+float MoveSpeed = 1.0f;      // Prędkość poruszania się
+
+
+float velocity = 0.0f;       // Aktualna prędkość łazika
+const float friction = 0.05f; // Współczynnik tarcia (μ)
+const float maxSpeed = 3.0f; // Maksymalna prędkość łazika
+const float acceleration = 0.2f;
+float rotationVelocity = 0.0f; // Prędkość obrotu łazika
+const float rotationAcceleration = 0.1f; // Przyspieszenie obrotu
+const float rotationFriction = 0.05f; // Współczynnik tarcia obrotu
+const float maxRotationSpeed = 3.0f; // Maksymalna prędkość obrotu
+
+
+
+
+
+// Funkcja do obracania łazika wokół osi Y
+void RotateRoverAndCamera(float angle) {
+	Rotation += angle;
+	if (Rotation >= 360.0f) Rotation -= 360.0f;
+	if (Rotation < 0.0f) Rotation += 360.0f;
+}
+void UpdateRover() {
+    bool isMovingForward = velocity > 0;
+
+    // Przyspieszanie w przód
+    if (keyWPressed) {
+        velocity += acceleration;
+        if (velocity > maxSpeed) velocity = maxSpeed;
+    }
+    // Przyspieszanie w tył
+    else if (keySPressed) {
+        velocity -= acceleration;
+        if (velocity < -maxSpeed) velocity = -maxSpeed;
+    }
+    // Hamowanie (wytracanie prędkości z powodu tarcia)
+    else {
+        if (velocity > 0) {
+            velocity -= friction;
+            if (velocity < 0) velocity = 0;
+        }
+        else if (velocity < 0) {
+            velocity += friction;
+            if (velocity > 0) velocity = 0;
+        }
+    }
+
+    // Zmienna do rozpoznania kierunku obrotu
+    int rotationDirection = 0;
+
+    // Obracanie (zależnie od kierunku ruchu)
+    if (keyAPressed) {
+        if (isMovingForward) {
+            // Obracanie w lewo, gdy poruszamy się do przodu
+            rotationDirection = -1;  // W lewo
+            rotationVelocity += rotationAcceleration;
+        } else {
+            // Obracanie w prawo, gdy poruszamy się do tyłu
+            rotationDirection = 1;   // W prawo
+            rotationVelocity -= rotationAcceleration;
+        }
+    }
+    else if (keyDPressed) {
+        if (isMovingForward) {
+            // Obracanie w prawo, gdy poruszamy się do przodu
+            rotationDirection = 1;   // W prawo
+            rotationVelocity -= rotationAcceleration;
+        } else {
+            // Obracanie w lewo, gdy poruszamy się do tyłu
+            rotationDirection = -1;  // W lewo
+            rotationVelocity += rotationAcceleration;
+        }
+    }
+    else {
+        // Trzeci warunek: Hamowanie obrotu (gdy brak wciśniętych klawiszy A i D, ale poruszamy się)
+        if (velocity != 0) {
+            if (rotationVelocity > 0) {
+                rotationVelocity -= rotationFriction;
+                if (rotationVelocity < 0) rotationVelocity = 0;
+            }
+            else if (rotationVelocity < 0) {
+                rotationVelocity += rotationFriction;
+                if (rotationVelocity > 0) rotationVelocity = 0;
+            }
+        }
+        else {
+            // Czwarty warunek: Kiedy nie poruszamy się ani do przodu, ani do tyłu
+            // Hamowanie obrotu, ale nie przyspieszamy
+            if (rotationVelocity > 0) {
+                rotationVelocity -= rotationFriction;
+                if (rotationVelocity < 0) rotationVelocity = 0;
+            }
+            else if (rotationVelocity < 0) {
+                rotationVelocity += rotationFriction;
+                if (rotationVelocity > 0) rotationVelocity = 0;
+            }
+        }
+    }
+
+    // Ogranicz prędkość obrotu, aby nie rosła zbyt szybko
+    if (rotationVelocity > maxRotationSpeed) rotationVelocity = maxRotationSpeed;
+    if (rotationVelocity < -maxRotationSpeed) rotationVelocity = -maxRotationSpeed;
+
+    // **Aktualizacja pozycji w kierunku przód-tył (ruch w osi Y)**:
+    // Poruszamy się na podstawie wartości `velocity` wzdłuż osi Y
+    float radRotation = Rotation * GL_PI / 180.0f;
+    Foward -= velocity * sin(radRotation);  // Przemieszczanie się wzdłuż osi Y (przód-tył)
+
+    // **Aktualizacja pozycji w lewo-prawo (ruch w osi X)**:
+    // Przemieszczanie w poziomie (w lewo/prawo) odbywa się w zależności od prędkości
+    Sides -= velocity * cos(radRotation);   // Przemieszczanie się wzdłuż osi X (lewo/prawo)
+
+    // Aktualizacja kąta obrotu (obrot w zależności od wartości `rotationVelocity`)
+    Rotation += rotationVelocity;
+    if (Rotation >= 360.0f) Rotation -= 360.0f;
+    if (Rotation < 0.0f) Rotation += 360.0f;
+}
+
+
+
+
+
+
+
 // Change viewing volume and viewport. Called when window is resized
 void ChangeSize(GLsizei w, GLsizei h) {
 	GLfloat nRange = 100.0f;