planowanie_ruchu

dijkstra.py

@@ -1,35 +1,5 @@
 import sys 
 
-def printSolution(dist, graph): 
-    print("Odleglosc punktow od wyznaczonego")
-    for node in range(len(graph)): 
-        print("Punkt: {} odleglosc: {}".format(node, dist[node]))
-
-
-def minDistance(graph, dist, sptSet): 
-    mini = sys.maxsize 
-    for v in range(len(graph)): 
-        if dist[v] < mini and sptSet[v] == False: 
-            mini = dist[v] 
-            min_index = v 
-    return min_index 
-
-
-def dijkstra(src, graph):
-    dist = [sys.maxsize] * len(graph)
-    dist[src] = 0
-    sptSet = [False] * len(graph)
-
-    for cout in range(len(graph)): 
-        u = minDistance(graph, dist, sptSet) 
-        sptSet[u] = True
-        for v in range(len(graph)):
-            if graph[u][v] > 0 and sptSet[v] == False and dist[v] > dist[u] + graph[u][v]: 
-                dist[v] = dist[u] + graph[u][v]
-
-    printSolution(dist, graph) 
-
-
 # Graf, koszt przejscia 1
 #  1- 2- 3- 4- 5
 #              |
@@ -40,7 +10,6 @@ def dijkstra(src, graph):
 # 20-19-18-17-16
 # |
 # 21-22-23-24-25
-
 graph = [[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #1
         [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #2
         [0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], #3
@@ -67,10 +36,40 @@ graph = [[0, 1, 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, 1, 0, 1], #24
         [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] ] #25
 
+def printSolution(dist): 
+    print("Odleglosc punktow od wyznaczonego")
+    for node in range(len(graph)): 
+        print("Punkt: {} odleglosc: {}".format(node, dist[node]))
+
+
+def minDistance(dist, sptSet): 
+    mini = sys.maxsize 
+    for v in range(len(graph)): 
+        if dist[v] < mini and sptSet[v] == False: 
+            mini = dist[v] 
+            min_index = v 
+    return min_index 
+
+
+def dijkstra(src):
+    dist = [sys.maxsize] * len(graph)
+    dist[src] = 0
+    sptSet = [False] * len(graph)
+
+    for cout in range(len(graph)): 
+        u = minDistance(dist, sptSet) 
+        sptSet[u] = True
+        for v in range(len(graph)):
+            if graph[u][v] > 0 and sptSet[v] == False and dist[v] > dist[u] + graph[u][v]: 
+                dist[v] = dist[u] + graph[u][v]
+
+    #printSolution(dist, graph) 
+    return dist
+
 
 #wypisuje tylko odpowiednio koszt przejscia do danego punktu
 #struktura grafu jest na tyle uproszczona ze nie trzeba wypisywac po kolei ktore punkty odwiedzamy
 #bo idziemy albo o punkt nizej albo wyzej
 #oczywiscie da to sie wszystko jakos bardziej rozwinac
 
-dijkstra(2, graph)
+#dijkstra(2)

main.py

@@ -1,40 +1,126 @@
 import pygame, sys
 from traktor import Traktor
+import dijkstra as di
 
 class Game(object):
 
     def __init__(self):
 
+        #to da sie chyba zrobic lepiej
+        #lokalizacje odpowiednich punktow na planszy
+        lokalizacje = [[0,0],
+                    [100, 0],
+                    [200, 0],
+                    [300, 0],
+                    [400, 0],
+                    [400, 100],
+                    [300, 100],
+                    [200, 100],
+                    [100, 100],
+                    [0, 100],
+                    [0, 200],
+                    [100, 200],
+                    [200, 200],
+                    [300, 200],
+                    [400, 200],
+                    [400, 300],
+                    [300, 300],
+                    [200, 300],
+                    [100, 300],
+                    [0, 300],
+                    [0, 400],
+                    [100, 400],
+                    [200, 400],
+                    [300, 400],
+                    [400, 400]]
+
         #inicjalizacja
         pygame.init()
-        self.pole = pygame.display.set_mode((1000,720))
+        self.pole = pygame.display.set_mode((501,501))
         
         self.player = Traktor(self)
 
+        sterowanie = int(input("Podaj czy chcesz sam sterowac traktorem - 1, czy chcesz podawac punkty - 0: "))
+        if sterowanie == 1:
+            sterowanie = True
+        else:
+            sterowanie = False
+
+        #iohiu;i;gou;ihpiu
         while True:
             #obsługa zdarzń
             for event in pygame.event.get():
                 if event.type == pygame.QUIT:
                     pygame.quit()
                     sys.exit(0)
+                #sterowanie traktorem
+                if sterowanie:
+                    if event.type == pygame.KEYDOWN :
+                        if event.key == pygame.K_UP:
+                            self.player.y -= 100
+                            if self.player.y < 0:
+                                self.player.y = 0
+                        if event.key == pygame.K_DOWN:
+                            self.player.y += 100
+                            if self.player.y > 400:
+                                self.player.y = 400
+                        if event.key == pygame.K_RIGHT:
+                            self.player.x += 100
+                            if self.player.x > 400:
+                                self.player.x = 400
+                        if event.key == pygame.K_LEFT:
+                            self.player.x -= 100
+                            if self.player.x < 0:
+                                self.player.x = 0
+                else:
+                    #po spacji wpisujemy punkty
+                    if event.type == pygame.KEYDOWN :
+                        if event.key == pygame.K_SPACE:
+                            pt = 0
+                            punkt1 = int(input("Podaj pierwszy punkt (liczba od 0 do 24): "))
+                            punkt2 = int(input("Podaj drugi punkt (liczba od 0 do 24): "))
+                            dist = di.dijkstra(self.player.punkt)
+
+                            if dist[punkt1] < dist[punkt2]:
+                                print("Wybralem pierwszy punkt")
+                                pt = punkt1
+                            else:
+                                print("Wybralem drugi punkt")
+                                pt = punkt2
+
+                            self.player.x = lokalizacje[pt][0]
+                            self.player.y = lokalizacje[pt][1]
+                            self.player.punkt = pt
+                        
 
             pygame.display.update()
 
-            self.tick()
             #rysowanie
             self.pole.fill((0,0,0))
+            self.krata()
             self.rysowanie()
             pygame.display.flip()
                     
     
-    def tick(self):
+    def krata(self):
-        #sprawdzanie klikniecia
+        #wymiary
+        w= 500
+        rows = 5
+        sizeBtw = w // rows
         
-        self.player.tick()
+        x = 0
+        y = 0
+        for r in range(rows):
+            x = x + sizeBtw
+            y = y + sizeBtw
+
+            #rysownie karaty
+            pygame.draw.line(self.pole, (255,255,255), (x,0), (x,w))
+            pygame.draw.line(self.pole, (255,255,255), (0,y), (w,y))
         
         
     def rysowanie(self):
-        #rysowanie
+        #rysowanie agenta
         self.player.rysowanie()
         
 

traktor.py

@@ -6,23 +6,12 @@ class Traktor(object):
     def __init__(self, game):
         #przekazywanie okiektu gra obiektowi traktor
         self.game = game
-        self.pozycja = Vector2(0,0)
+        self.x = 0
-        
+        self.y = 0
-
+        self.punkt = 0
-    def tick(self):
+        self.canSteer = True
-        #kliknięcia
-        pressed = pygame.key.get_pressed()
-        if pressed[pygame.K_UP]:
-            self.pozycja.y -= 5
-        if pressed[pygame.K_DOWN]:
-            self.pozycja.y += 5
-        if pressed[pygame.K_RIGHT]:
-            self.pozycja.x += 5
-        if pressed[pygame.K_LEFT]:
-            self.pozycja.x -= 5
-        
             
         
     def rysowanie(self):      
-        obje = pygame.Rect(self.pozycja.x, self.pozycja.y ,50,50)
+        obje = pygame.Rect(self.x, self.y ,99,99)
-        pygame.draw.rect(self.game.pole, (0,150,255), obje)
+        pygame.draw.rect(self.game.pole, (0,100,255), obje)