Added flight restriction boundary

The planes are now bound to a certain flying region and turn to center when trying to escape said region.

Additional refactors

Author: HyperToken9

main.py

@@ -4,26 +4,31 @@
 from PIL import Image
 from pynput.mouse import Button, Controller
 
-## Updates
+# TODO:
 # Spawn Optimization
 # Landing Bug
 
-# Initalize Pygame
+# Initialize Pygame
 pygame.init()
 
-# Setup the clock for a decent framerate
+# Setup the clock for a decent frame rate
 clock = pygame.time.Clock()
 
 # Background Image
 background = pygame.image.load('Flight-Control-Bot/Map.png')
 
 # Creating a Window
-screen_width = 1920/2
-screen_height = 1080/2
-screen = pygame.display.set_mode((screen_width, screen_height))
+screen_width = 1920 / 2
+screen_height = 1080 / 2
+screen = pygame.display.set_mode((1920 / 2, 1080 / 2))
 
-def dist(x,y):
-    distance = (((x[0] - y[0]) ** 2) + ((x[1] - y[1] ) ** 2)) ** (0.5)
+green_dots = []
+red_dot = pygame.image.load('Flight-Control-Bot/red_dot.png')
+green_dot = pygame.image.load('Flight-Control-Bot/green_dot.png')
+
+
+def dist(x, y):
+    distance = (((x[0] - y[0]) ** 2) + ((x[1] - y[1]) ** 2)) ** 0.5
     return distance
 
 
@@ -40,57 +45,50 @@ def orientation(p1, p2, p3):
           (float(p2[0] - p1[0]) * (p3[1] - p2[1]))
     # print(val)
 
-    if (val == 0):
+    if val == 0:
         # Clockwise orientation
-        if (dist(p1, p3) < dist(p2, p3)):
+        if dist(p1, p3) < dist(p2, p3):
             result = 0
         else:
             result = 100
     else:
         # Counterclockwise orientation
-        result =  -1 * val
+        result = -1 * val
 
     # print(result)
-    return (result - 0.5)
-
+    return result - 0.5
 
-green_dots = [[0, screen_height - 60], [screen_width/2, screen_height/2]]
-red_dot = pygame.image.load('Flight-Control-Bot/red_dot.png')
-green_dot = pygame.image.load('Flight-Control-Bot/green_dot.png')
 
 class Plane:
     global screen
 
-    def __init__(self, spawn_at = [750,100], offset_Angle = -2, LandAngle = 0, Path = None):
+    def __init__(self, spawn_at=[750, 100], offset_angle=-2):
 
         # Images
         self.Image_Path = "Flight-Control-Bot/Plane1.png"
         self.img_pure = Image.open(self.Image_Path)
-        self.img_og =  pygame.image.load(self.Image_Path)
-        self.img_gpy = pygame.transform.rotate(self.img_og, offset_Angle)
+        self.img_og = pygame.image.load(self.Image_Path)
+        self.img_gpy = pygame.transform.rotate(self.img_og, offset_angle)
 
         # Speed
         self.Speed = 0.4
         self.flying = True
 
         # Position
-        self.position = spawn_at#[random.randint(0, 1920/2), random.randint(0, 540)]
+        self.position = spawn_at  # [random.randint(0, 1920/2), random.randint(0, 540)]
 
         # Angle In Degrees
-        self.Angle = self.angle_to_center() # random.randint(0, 180)
+        self.Angle = self.angle_to_center()  # random.randint(0, 180)
         print(f"{self.Angle}")
 
-        self.OffsetAngle = offset_Angle
-
+        self.OffsetAngle = offset_angle
 
         self.landing_strip = np.array([(372, 192), (565, 248)])
 
         # self.Tow = False
-        self.shrinkage = [i for i in range(80, 10, -3)]
+        self.shrinkage = [j for j in range(80, 10, -3)]
 
-        self.Path = Path#[[200, 200], [300, 300], [400, 200], [500, 300], [600, 200]]
-        if self.Path is None:
-            self.Path = []
+        self.Path = []
 
         self.Tow = False
 
@@ -104,10 +102,17 @@ def __init__(self, spawn_at = [750,100], offset_Angle = -2, LandAngle = 0, Path
             self.red_dots.append(i)
         self.turn(0)
 
+    # Turns the plane by a certain bank angle
     def turn(self, bank):
         self.Angle += bank
         self.img_gpy = pygame.transform.rotate(self.img_og, self.OffsetAngle + self.Angle)
 
+    # Turns the plane to a Certain Angle
+    def turn_to(self, angle):
+        self.Angle = angle
+        self.img_gpy = pygame.transform.rotate(self.img_og, self.OffsetAngle + self.Angle)
+
+    # Starts to fade the sprite on approaching landing
     def fade(self):
         self.img_og.fill((255, 255, 255, int(self.alpha)), special_flags=pygame.BLEND_RGBA_MULT)
         self.alpha /= 1.2
@@ -122,40 +127,52 @@ def fade(self):
     def fly(self):
         self.tick += 1
 
-        bank = 5
+        # Tuning Turing Intensity
         fine_bank = 0.01
 
-
-        if (self.flying == False):
-            if (self.tick% 40 == 0):
-                print("Tick")
-                print("landing: ",self.landing_strip)
-                if (self.Path[0] in self.landing_strip):
+        if not self.flying:
+            if self.tick % 40 == 0:
+                # print("Tick")
+                # print("landing: ",self.landing_strip)
+                if self.Path[0] in self.landing_strip:
                     self.fade()
 
-
-
-        if (len(self.Path) != 0):
+        if len(self.Path) != 0:
             # if (self.Path[0] not in red_dots):
             #     red_dots.append(self.Path[0])
             dest = self.Path[0]
             head = self.head_pose()
             tail = self.tail_pose()
             mid = (head + tail) / 2
 
-            turn_direction = orientation(head, tail ,dest) * fine_bank
+            turn_direction = orientation(head, tail, dest) * fine_bank
             # print("Ore", orientation(head, tail, dest))
             # print("turnDir", turnDir)
             self.turn(turn_direction)
 
-            if (dist(mid, self.Path[0]) < 15):
+            if dist(mid, self.Path[0]) < 15:
                 reached = self.Path.pop(0)
                 self.red_dots.pop(0)
                 # green_dots.append(reached)
                 # print("Reached", reached)
 
+        self.restrict_fly_zone()
+
         self.position = [self.position[0] + self.Speed * math.cos(math.radians(self.Angle)),
-                    self.position[1] - self.Speed * math.sin(math.radians(self.Angle))]
+                         self.position[1] - self.Speed * math.sin(math.radians(self.Angle))]
+
+    # Keeps the plane bound to the screen
+    def restrict_fly_zone(self):
+        # No restriction during early flight
+
+        if self.tick < 500:
+            return
+
+        if -25 < self.position[0] < screen_width - 10 and -25 < self.position[1] < screen_height - 10:
+            return
+
+        self.turn_to(self.angle_to_center())
+        print("Out of Bounds")
 
     def land(self):
         if (len(self.LandLoc) == 1):
@@ -164,73 +181,69 @@ def land(self):
     def draw(self):
         screen.blit(self.img_gpy, self.position)
         # Path Visualization
+        # Comment to disable Path Visualization
         self.path_vis()
 
     def Towing(self, mouse_position, click_status):
         # When Clicked Start towing plane with mouse
-        if (click_status[0] == True):
-            if (dist(mouse_position, (self.position[0] + (self.img_pure.size[0]/2),
-                                      self.position[1] + (self.img_pure.size[1]/2))) < 35):
-                if (len(self.Path) > 0):
+        if click_status[0]:
+            if (dist(mouse_position, (self.position[0] + (self.img_pure.size[0] / 2),
+                                      self.position[1] + (self.img_pure.size[1] / 2))) < 35):
+                if len(self.Path) > 0:
                     self.Path.clear()
                     self.red_dots.clear()
                 self.Tow = True
                 # print("Towing")
 
-        if (self.Tow == True):
-            if (click_status[0] == False):
+        if self.Tow:
+            if not click_status[0]:
                 self.Tow = False
                 # print("UnTOWED")
-            elif (dist(mouse_position, self.landing_strip[0]) < 15):
+            elif dist(mouse_position, self.landing_strip[0]) < 15:
                 self.flying = False
                 for i in self.landing_strip:
                     self.Path.append(i)
                     self.red_dots.append(i)
                 # print("Locked")
-                self.Tow = False;
+                self.Tow = False
 
             else:
-                print(mouse_position)
+                # print(mouse_position)
                 self.red_dots.append(mouse_position)
                 self.Path.append(mouse_position)
                 # print(self.Path)
 
+    # Give angle to center from current position
+    def angle_to_center(self):
+        screen_center = [screen_width / 2, screen_height / 2]
+        return self.angle(self.position, screen_center)
+
+    @staticmethod
+    def angle(coord1, coord2):
+
+        numerator =  coord1[1] - coord2[1]
+        denominator = coord2[0] - coord1[0]
+        degrees = math.degrees(math.atan2(numerator, denominator))
+
+        return degrees
+
     def head_pose(self):
         # green_dots.append(self.Pos)
         theta = 90
         angle = self.Angle + theta
         head_loc = (self.position[0] + 30 + (27 * math.cos(math.radians(self.Angle))
-                                            - 2 * math.sin(math.radians(self.Angle))),
-                         self.position[1] + 30 + (-27 * math.sin(math.radians(self.Angle))
-                                              -2 * math.cos(math.radians(self.Angle))))
+                                             - 2 * math.sin(math.radians(self.Angle))),
+                    self.position[1] + 30 + (-27 * math.sin(math.radians(self.Angle))
+                                             - 2 * math.cos(math.radians(self.Angle))))
 
         # red_dots.append(head_loc)
         return np.array(head_loc)
 
-    def angle_to_center(self):
-        screen_center = [screen_width/2, screen_height/2]
-        return self.angle(self.position, screen_center)
-
-    @staticmethod
-    def angle(coord1, coord2):
-        print(coord1,coord2)
-        try:
-            slope = -1 * (coord2[1] - coord1[1]) / (coord2[0] - coord1[0])
-        except ZeroDivisionError:
-            if(coord2[1] - coord1[1] > 0):
-                return -90
-            else:
-                return  90
-
-        degs = math.degrees(math.atan2(-1 * (coord2[1] - coord1[1]) , (coord2[0] - coord1[0])))
-        print(degs)
-        return degs
-
     def tail_pose(self):
         theta = 90
         angle = self.Angle + theta
         tail_loc = (self.position[0] + 30 + (-29 * math.cos(math.radians(self.Angle))),
-                    self.position[1] + 30 + ( 29 * math.sin(math.radians(self.Angle))))
+                    self.position[1] + 30 + (29 * math.sin(math.radians(self.Angle))))
 
         # red_dots.append(tail_loc)
         return np.array(tail_loc)
@@ -246,43 +259,46 @@ def path_vis(self):
 
 class Fleet:
 
-    planes = []
+    def __init__(self):
+
+        self.planes = []
 
     def Manage(self, mouse_position, mouse_press_status):
         # if (time.time() == 1000)
         for i in self.planes:
             i.draw()
             i.fly()
             i.Towing(mouse_position, mouse_press_status)
-            if(i.alpha < 100):
+            if i.alpha < 100:
                 self.planes.pop(self.planes.index(i))
 
-    def speacialPlane(self, plane):
+    def specialPlane(self, plane):
         self.planes.append(plane)
 
     def Spawner(self):
-        should_spawn = random.choices([1,0], weights=(1, 1000), k = 1)[0]
-        if (should_spawn):
+        should_spawn = random.choices([1, 0], weights=(1, 10000), k=1)[0]
+        if should_spawn:
             self.spawn()
 
-
     def spawn(self):
-        spawn_spots = {'up': [[0, -60], [screen_width, -10]], 'down': [[0, screen_height - 60 ], [screen_width, screen_height]],
-                       'left': [[-60, 0], [0, screen_height]], 'right': [[screen_width, 0], [screen_width + 60, screen_height]]}
+        spawn_spots = {'up': [[0, -60], [screen_width, -10]],
+                       'down': [[0, screen_height - 60], [screen_width, screen_height]],
+                       'left': [[-60, 0], [0, screen_height]],
+                       'right': [[screen_width, 0], [screen_width + 60, screen_height]]}
 
         _, spawn_rect = random.choice(list(spawn_spots.items()))
 
         spawn_location = [random.randint(spawn_rect[0][0], spawn_rect[1][0]),
                           random.randint(spawn_rect[0][1], spawn_rect[1][1])]
-        self.planes.append(Plane(spawn_at= spawn_location))
+        self.planes.append(Plane(spawn_at=spawn_location))
 
 
 test_fleet = Fleet()
 
 # Special Plane Instance
 # Plane1 h = 37.5685 w = 37.56
 # plane1 = Plane( Angle = 90, Pos = (20, 170))
-# test_fleet.speacialPlane(plane1)
+# test_fleet.specialPlane(plane1)
 
 # Running Indicator
 running = True
@@ -294,35 +310,26 @@ def spawn(self):
 while running:
     # Screen Color
     screen.fill((255, 255, 255))
-    screen.blit(background, (0,0))
-
+    screen.blit(background, (0, 0))
 
     # Loop through pygame functions
     for event in pygame.event.get():
-        ## Here we are looking for a very specific event
-        ## Which is quit. and when it has occured we change a variable which
-        ## causes our program to end
+        # Here we are looking for a very specific event
+        # Which is quit. and when it has occurred we change a variable which
+        # causes our program to end
         if event.type == pygame.QUIT:
             running = False
 
     test_fleet.Spawner()
     test_fleet.Manage(pygame.mouse.get_pos(), pygame.mouse.get_pressed())
 
-
-    ## DEBUGGING TOOLS
+    # DEBUGGING TOOLS
     for i in green_dots:
         screen.blit(green_dot, (i[0] - 4, i[1] - 4))
 
-
-
-
     # if(int(time.time())%10 == 0):
     #     print(pygame.mouse.get_pressed())
     # for i in planes:
     #     i.Head()
 
-
     pygame.display.update()
-
-
-