diff --git a/FPSCounter.cpp b/FPSCounter.cpp
index 61144c3..5fd25eb 100644
--- a/FPSCounter.cpp
+++ b/FPSCounter.cpp
@@ -10,6 +10,7 @@ public:
         auto currentTime = std::chrono::high_resolution_clock::now();
         std::chrono::duration<double> elapsed = currentTime - lastTime;
 
+        // Aktualizujemy FPS co 1 sekundê
         if (elapsed.count() >= 1.0) {
             double fps = frameCount / elapsed.count();
             std::cout << "FPS: " << fps << std::endl;
diff --git a/Rover.cpp b/Rover.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/grafikaKBT.vcxproj b/grafikaKBT.vcxproj
index 28784d3..8d5ad99 100644
--- a/grafikaKBT.vcxproj
+++ b/grafikaKBT.vcxproj
@@ -123,6 +123,7 @@
   <ItemGroup>
     <ClCompile Include="FPSCounter.cpp" />
     <ClCompile Include="glew.c" />
+    <ClCompile Include="Rover.cpp" />
     <ClCompile Include="lazik.cpp" />
     <ClCompile Include="loadOBJ.cpp" />
     <ClCompile Include="main.cpp" />
diff --git a/grafikaKBT.vcxproj.filters b/grafikaKBT.vcxproj.filters
index 2f91739..3bbb550 100644
--- a/grafikaKBT.vcxproj.filters
+++ b/grafikaKBT.vcxproj.filters
@@ -36,6 +36,15 @@
     <ClCompile Include="FPSCounter.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="shader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="texture.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Rover.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="loadOBJ.h">
@@ -65,4 +74,4 @@
       <Filter>Source Files</Filter>
     </None>
   </ItemGroup>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
index 09c6159..8f2c5e7 100644
--- a/main.cpp
+++ b/main.cpp
@@ -85,19 +85,25 @@ std::time_t monitormodehelper;
 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();
+	static auto lastTime = std::chrono::steady_clock::now();
+	auto currentTime = std::chrono::steady_clock::now();
 	std::chrono::duration<double> elapsed = currentTime - lastTime;
 
-	// Jeśli upłynęło za mało czasu, aby osiągnąć target FPS, czekamy
+	// Obliczamy czas na jednÄ… klatkÄ™
 	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()));
+	double timeToWait = frameTime - elapsed.count(); // Obliczamy czas do czekania
+
+	if (timeToWait > 0.0) {
+		// Jeśli czas do czekania jest większy niż 0, to śpimy przez tę wartość
+		std::this_thread::sleep_for(std::chrono::duration<double>(timeToWait));
 	}
 
-	lastTime = std::chrono::high_resolution_clock::now();
+	lastTime = currentTime; // Zaktualizuj czas dla następnej iteracji
 }
+
+bool Kolizja = false;
 bool keyWPressed = false;
 bool keySPressed = false;
 bool keyAPressed = false;
@@ -112,46 +118,67 @@ float MoveSpeed = 1.0f;      // Prędkość poruszania się
 
 
 float velocity = 0.0f;       // Aktualna prędkość łazika
-const float friction = 0.1f; // Współczynnik tarcia (μ)
+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
 
+// Struktura do reprezentacji płotu
+struct Plot {
+	GLfloat xc;       // Środek płotu w osi X
+	GLfloat yc;       // Środek płotu w osi Y (nieużywane w kolizji, ale może być pomocne)
+	GLfloat zc;       // Środek płotu w osi Z
+	GLfloat length;   // Długość płotu
+	GLfloat gruboscY; // Grubość płotu
+	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
+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)
+		float xMin = plot.xc - plot.gruboscY / 2.0f;
+		float xMax = plot.xc + plot.gruboscY / 2.0f;
+		float zMin = plot.zc - plot.length / 2.0f;
+		float zMax = plot.zc + plot.length / 2.0f;
 
-
-// Funkcja do poruszania Å‚azikiem
-void MoveRover(bool forward) {
-	// Zamieniamy kÄ…t na radiany
-	float radRotation = Rotation * GL_PI / 180.0f;
-
-	// Wektor ruchu w kierunku przód/tył (kierunek łazika)
-	float moveX = cos(radRotation);
-	float moveZ = sin(radRotation);
-
-	// Ruch w przód
-	if (forward) {
-		Sides -= MoveSpeed * moveX;
-		Foward -= MoveSpeed * moveZ;
+		// Sprawdzenie, czy którykolwiek fragment łazika wchodzi w obszar płotu
+		if (roverXMax >= xMin && roverXMin <= xMax && // Kolizja w osi X
+			roverZMax >= zMin && roverZMin <= zMax) { // Kolizja w osi Z
+			return true;
+		}
 	}
-	// Ruch w tył
-	else {
-		Sides += MoveSpeed * moveX;
-		Foward += MoveSpeed * moveZ;
+	else { // 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;
+		float zMax = plot.zc + plot.gruboscY / 2.0f;
+
+		// Sprawdzenie, czy którykolwiek fragment łazika wchodzi w obszar płotu
+		if (roverXMax >= xMin && roverXMin <= xMax && // Kolizja w osi X
+			roverZMax >= zMin && roverZMin <= zMax) { // Kolizja w osi Z
+			return true;
+		}
 	}
+	return false;
 }
 
-// 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;
+// Funkcja ogólna do sprawdzania kolizji ze wszystkimi płotami
+bool CheckAllFencesCollision(float roverXMin, float roverXMax, float roverZMin, float roverZMax, const std::vector<Plot>& fences) {
+	for (const auto& fence : fences) {
+		if (CheckFenceCollision(roverXMin, roverXMax, roverZMin, roverZMax, fence)) {
+			return true; // Kolizja wykryta z którymś płotem
+		}
+	}
+	return false; // Brak kolizji
 }
 
-void UpdateRover() {
+void UpdateRover(const std::vector<Plot>& fences) {
 	// Przyspieszanie w przód
 	if (keyWPressed) {
 		velocity += acceleration;
@@ -195,17 +222,77 @@ void UpdateRover() {
 		}
 	}
 
-	// Aktualizacja pozycji na podstawie prędkości
-	float radRotation = Rotation * GL_PI / 180.0f;
-	Sides -= velocity * cos(radRotation);
-	Foward -= velocity * sin(radRotation);
+	// Wyliczenie nowej pozycji na podstawie prędkości
+	float radRotation = Rotation * GL_PI / 180.0f; // Przeliczamy rotacjÄ™ na radiany
+	float newSides = Sides - velocity * cos(radRotation); // Nowa pozycja w osi X
+	float newFoward = Foward - velocity * sin(radRotation); // Nowa pozycja w osi Z
 
-	// Aktualizacja kÄ…ta obrotu
-	Rotation += rotationVelocity;
-	if (Rotation >= 360.0f) Rotation -= 360.0f;
-	if (Rotation < 0.0f) Rotation += 360.0f;
+	// Wyliczenie obszaru zajmowanego przez Å‚azik
+	float roverXMin = newSides - 15.0f;
+	float roverXMax = newSides + 15.0f;
+	float roverZMin = newFoward - 15.0f;
+	float roverZMax = newFoward + 15.0f;
+
+	// Sprawdzanie kolizji przed aktualizacjÄ… pozycji
+	if (Kolizja == true) {
+		if (CheckAllFencesCollision(roverXMin, roverXMax, roverZMin, roverZMax, fences)) {
+			// Jeśli jest kolizja, zatrzymujemy łazik
+			velocity = 0.0f;
+			cout << "Kolizja podczas ruchu\n";
+		}
+		else {
+			// Jeśli brak kolizji, aktualizujemy pozycję
+			Sides = newSides;
+			Foward = newFoward;
+		}
+
+		// Sprawdzanie kolizji podczas obrotu
+		if (rotationVelocity != 0.0f) {
+			// Wyliczamy narożniki łazika po obrocie
+			float newRotation = Rotation + rotationVelocity;
+			float radNewRotation = newRotation * GL_PI / 180.0f;
+
+			// Wyliczamy offsety narożników w nowych współrzędnych
+			float offsetX = 15.0f * cos(radNewRotation);
+			float offsetZ = 15.0f * sin(radNewRotation);
+
+			// Wyznaczamy nowe granice Å‚azika
+			float rotatedXMin = Sides - offsetX;
+			float rotatedXMax = Sides + offsetX;
+			float rotatedZMin = Foward - offsetZ;
+			float rotatedZMax = Foward + offsetZ;
+
+			// Sprawdzamy kolizjÄ™ dla granic po obrocie
+			if (CheckAllFencesCollision(rotatedXMin, rotatedXMax, rotatedZMin, rotatedZMax, fences)) {
+				rotationVelocity = 0.0f; // Zatrzymujemy obrót w przypadku kolizji
+				cout << "Kolizja podczas obrotu\n";
+			}
+			else {
+				// Aktualizujemy rotację tylko, jeśli nie ma kolizji
+				Rotation = newRotation;
+				if (Rotation >= 360.0f) Rotation -= 360.0f;
+				if (Rotation < 0.0f) Rotation += 360.0f;
+			}
+		}
+	}
+	else {
+		// Jeśli kolizje są wyłączone, aktualizujemy wszystko bez sprawdzania
+		Sides = newSides;
+		Foward = newFoward;
+		Rotation += rotationVelocity;
+		if (Rotation >= 360.0f) Rotation -= 360.0f;
+		if (Rotation < 0.0f) Rotation += 360.0f;
+	}
 }
 
+
+std::vector<Plot> fences = {
+	{-10.0f, 3.0f,  45.0f, 130.0f, 4.0f, 0},
+	{ 50.0f, 3.0f, -20.0f, 120.0f, 4.0f, 1},
+	{110.0f, 3.0f,  45.0f, 130.0f, 4.0f, 0},
+	{ 50.0f, 3.0f, 110.0f, 120.0f, 4.0f, 1}
+};
+
 // Change viewing volume and viewport. Called when window is resized
 void ChangeSize(GLsizei w, GLsizei h) {
 	GLfloat nRange = 100.0f;
@@ -769,6 +856,7 @@ void SetupRC() {
 
 void RenderScene(void) {
 	
+	
 	//float normal[3];	// Storage for calculated surface normal
 
 	// Save the matrix state and do the rotations
@@ -817,7 +905,7 @@ void RenderScene(void) {
 		Foward, 0.0f, Sides,                                      // Punkt, na który patrzy kamera (łazik)
 		0.0f, 1.0f, 0.0f                                         // Wektor "góry"
 	);
-
+	
 	// Rysowanie mapy (nie porusza siÄ™)
 	glPushMatrix();
 	glColor3f(0.0, 1.0, 0.0);              // Zielony kolor dla mapy
@@ -827,12 +915,13 @@ void RenderScene(void) {
 
 	// Rysowanie Å‚azika (porusza siÄ™ i obraca)
 	glPushMatrix();
-	
+
 	glTranslatef(Foward, 0.0f, Sides);     // Translacja Å‚azika na jego pozycjÄ™
 	glRotatef(Rotation, 0.0f, 1.0f, 0.0f); // Obrót łazika wokół własnej osi
 	glColor3f(1.0, 0.0, 0.0);              // Czerwony kolor dla Å‚azika
+	fpsCounter.update();
 	user.draw();
-	UpdateRover();
+	UpdateRover(fences);
 	glPopMatrix();
 
 	//skrzynka(50);
@@ -850,7 +939,7 @@ void RenderScene(void) {
 	//glColor3f(0.0, 1.0, 0.0);
 	//mapa.draw();
 	//glColor3f(0.0, 0.0, 0.0);
-	fpsCounter.update();
+	
 
 	// Zamiana buforów (double buffering)
 
@@ -1160,11 +1249,10 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 			//break;
 
 			// Limit FPS
-			LimitFPS(targetFPS);
+			// Uaktualniaj FPS
+			LimitFPS(targetFPS);  // Ogranicz FPS
 
-			// Update FPS counter
-			if (monitormode) fpsCounter.update();
-			break;
+			
 
 		case WM_QUERYNEWPALETTE:
 			// If the palette was created.
@@ -1266,6 +1354,9 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 					polygonmode = !polygonmode;
 					if (polygonmode) timestampedCout("Uwaga! Tryb wireframe jest niewydajny i powinien sluzyc tylko do debugowania!");
 					break;
+				case 'K':
+					Kolizja = !Kolizja;
+					break;
 
 				case 'W':
 					keyWPressed = true;