boosters now spawn, and decrease timer activates and works

Author: Y3drk

CSVParser.py

@@ -44,6 +44,7 @@ def draw_map(self, map: map):
             elif row[0] == "SURFACE":
                 if row[5] == "ASPHALT":
                     map.all_surfaces.add(Surface(position, width, height, SurfaceType.ASPHALT, rotation))
+                    map.places_for_boosters.append([position.x + 40, position.y + 40, position.x + width - 40, position.y + height - 40])
 
                 elif row[5] == "SNOW":
                     map.all_surfaces.add(Surface(position, width, height, SurfaceType.SNOW, rotation))

booster.py

@@ -7,9 +7,10 @@
 
 
 class Booster (pg.sprite.Sprite):
-    def __init__(self, position: Vector2D, change: int, image_name, type: BoosterType, dt): #change -> wartośc zmiany, jesli dotyczy zmian boolowskich to ==1
+    def __init__(self, position: Vector2D, change: int, type: BoosterType, dt): #change -> wartośc zmiany, jesli dotyczy zmian boolowskich to ==1
         pg.sprite.Sprite.__init__(self)
-        self.image = pg.image.load("./data/quick_racing_booster_"+image_name+".png").convert() # make booster images
+        self.image = pg.image.load("./data/quick_racing_booster_"+type.value[1]+".png").convert_alpha() # make booster images
+        self.image.set_colorkey((0,0,0))
         self.rect = self.image.get_rect()
         self.rect.x = position.x
         self.rect.y = position.y
@@ -24,6 +25,7 @@ def __init__(self, position: Vector2D, change: int, image_name, type: BoosterTyp
         self.mask = pg.mask.from_surface(self.image)
 
     def activate(self, car: Car, stopwatch: Stopwatch):
+            print("Booster is activating")
             if self.type == BoosterType.SPEED:
                 car.speed += self.int_booster_value
                 #sleep(3)
@@ -36,18 +38,19 @@ def activate(self, car: Car, stopwatch: Stopwatch):
                 pass
 
             elif self.type == BoosterType.DECREASE_TIMER: #the time of the lap is decreased
-                stopwatch.decrease_timer(1000)
+                print("deacreasing time")
+                stopwatch.decrease_timer(4000)
 
             elif self.type == BoosterType.FREEZE:
                 car.speed = 0
 
             else: #BoosterType.NO_TURNING -> self descriptive
                 pass
 
-            # we gotta find a way to make it last only a short amount of time -> like 3 seconds or so
+# we gotta find a way to make it last only a short amount of time -> like 3 seconds or so
 
-            #we can use dt
-            #we can also add "push" or something - it'd be like booster but with a single push (increase in speed in facing direction)
-            # -maybe maybe
+#we can use dt
+#we can also add "push" or something - it'd be like booster but with a single push (increase in speed in facing direction)
+# -maybe maybe
 
 

boosterType.py

@@ -3,13 +3,13 @@
 
 class BoosterType(Enum):
     #both positive and negative
-    SPEED = 1
-    TURNING = 2
+    SPEED = (1, (255, 255, 255))
+    TURNING = (2, (255, 255, 255))
 
     #only positive
-    NO_COLLISIONS = 3
-    DECREASE_TIMER = 4
+    NO_COLLISIONS = (3, (255, 255, 255))
+    DECREASE_TIMER = (4, "dt_resized")
 
     #only negative
-    NO_TURNING = 5
-    FREEZE = 6
+    NO_TURNING = (5, (255, 255, 255))
+    FREEZE = (6, (255, 255, 255))

car.py

@@ -39,6 +39,9 @@ def update(self, dt):
 
             self.speed = -self.speed * 0.15
 
+        new_traction = self.map.handle_collision_with_sufraces(self)
+        self.map.handle_collision_with_boosters(self)
+
         self.rect = self.image.get_rect()
         self.rect.x, self.rect.y = self.position.x, self.position.y
 

data/quick_racing_booster_dt_resized.png

@@ -1,11 +1,14 @@
 from __future__ import annotations
+
+import asyncio
+import random
+
 import pygame as pg
+
+import boosterType
 from vector2d import Vector2D
 from car import Car
 from map import Map
-from wall import Wall
-from surface import Surface
-from surfaceType import SurfaceType
 from stopwatch import Stopwatch
 from booster import Booster
 from boosterType import BoosterType
@@ -21,12 +24,6 @@ def __init__(self, refresh_rate):
         pg.display.set_caption("QUICK RACING")
         self.clock = pg.time.Clock()
 
-        #move to map
-        # self.all_walls = pg.sprite.Group()
-        # self.all_surfaces = pg.sprite.Group()
-
-        #it would be nice if booster stayed here
-        self.all_boosters = pg.sprite.Group()
 
     # btw that's how we can load the map -> read all walls size and location from CSV then create
     # them and add them all to sprite group,
@@ -35,6 +32,51 @@ def __init__(self, refresh_rate):
 
     #thought exactly the same thing :) -> can be done today during labs
 
+    def spawn_booster(self, map: Map, dt):
+
+        if random.randrange(0, 256) != 8:
+            return
+
+        place = random.randrange(0, len(map.places_for_boosters)-1)
+        x_coordinate = random.randrange(map.places_for_boosters[place][0], map.places_for_boosters[place][2])
+        y_coordinate = random.randrange(map.places_for_boosters[place][1], map.places_for_boosters[place][3])
+
+
+        what_booster = random.randrange(0,5)
+        new_booster_type = None
+        change = None
+
+        #temp
+        what_booster = 3
+
+        if what_booster == 0:
+            new_booster_type = BoosterType.SPEED
+            change = random.randrange(-100, 100)
+
+        elif what_booster == 1:
+            new_booster_type = BoosterType.TURNING
+            change = random.randrange(-3 , 3)
+
+        elif what_booster == 2:
+            new_booster_type = BoosterType.NO_COLLISIONS
+            change = 1
+
+        elif what_booster == 3:
+            new_booster_type = BoosterType.DECREASE_TIMER
+            change = 1
+
+        elif what_booster == 4:
+            new_booster_type = BoosterType.NO_TURNING
+            change = 1
+
+        elif what_booster == 5:
+            new_booster_type = BoosterType.FREEZE
+            change = 1
+
+        map.all_boosters.add(Booster(Vector2D(x_coordinate, y_coordinate), change, new_booster_type, dt))
+        #print("Booster spawned!\n")
+
+
     def start_timer(self):
         stopwatch = Stopwatch(self.screen, self.clock, Vector2D(1300, 40))
         stopwatch.restart_timer(pg.time.get_ticks())
@@ -51,15 +93,15 @@ def run(self):
 
         x, y = self.screen.get_size()
 
-        curr_map = Map(0, x, y)
+        run = True
+        stopwatch = self.start_timer()
+
+        curr_map = Map(0, x, y, stopwatch)
         map_img = pg.image.load("./data/grass.png")
         curr_map.place_objects()
 
         car = Car(0, Vector2D(50, 100), 0, 0, 10, 50, curr_map)
 
-        run = True
-        stopwatch = self.start_timer()
-
         while run:
             dt = self.clock.tick(self.refresh)
             self.screen.blit(map_img, (0, 0))
@@ -74,6 +116,11 @@ def run(self):
             curr_map.all_walls.draw(self.screen)
             curr_map.all_walls.update()
 
+            self.spawn_booster(curr_map, dt)
+
+            curr_map.all_boosters.draw(self.screen)
+            curr_map.all_boosters.update()
+
             car.move(dt) # maybe car also should be coded as a sprite???
             car.update(dt)
 

engine.py

@@ -2,29 +2,29 @@
 import pygame as pg
 
 from CSVParser import CSVParser
-from vector2d import Vector2D
-from wall import Wall
-from surface import Surface
-from surfaceType import SurfaceType
 
-from math import sin, cos, radians, sqrt
+from math import sin, cos, radians
 
 
 class Map:
-    def __init__(self, id, width, height):
+    def __init__(self, id, width, height, stopwatch):
         self.id = id
         self.width = width
         self.height = height
         self.all_walls = pg.sprite.Group()
         self.all_surfaces = pg.sprite.Group()
-        self.all_booster = pg.sprite.Group()
+        self.all_boosters = pg.sprite.Group()
+        self.places_for_boosters = []
         self.name = "Map"
+        self.stopwatch = stopwatch
 
     def place_objects(self):
         parser = CSVParser("./data/map1.csv", "../data/Leaderboard.csv")
 
         parser.draw_map(self)
 
+        #print(self.places_for_boosters)
+
         # surface1 = Surface(Vector2D(100, 100), 1500, 110, SurfaceType.ASPHALT)
         # self.all_surfaces.add(surface1)
 
@@ -129,24 +129,24 @@ def place_objects(self):
     def handle_collision_with_walls(self, car):
         collisions = pg.sprite.spritecollide(car, self.all_walls, False, pg.sprite.collide_mask)
         if collisions:  # it's a list of objects/sprites that collided with the car
-            print("Collision with wall")
             for col in collisions:
                 return True
 
         return False
 
-    def handle_collision_with_sufraces(self, car, traction: float):
+    def handle_collision_with_sufraces(self, car):
         slides = pg.sprite.spritecollide(car, self.all_surfaces, False, pg.sprite.collide_mask)
         if slides:
             for slide in slides:
                 if slide.rect.x == car.rect.x + car.speed * cos(
                         radians(car.direction)) and slide.rect.y == car.rect.y + car.speed * sin(
                         radians(car.direction)):
-                    traction = slide.adjust_fraction() #do sth about it later on!
+                        return slide.adjust_fraction() #do sth about it later on!
 
     def handle_collision_with_boosters(self, car):
         # collisions with boosters
-        pick_ups = pg.sprite.spritecollide(car, self.all_boosters, False, pg.sprite.collide_mask)  # maybe in this case it can be set to true
+        pick_ups = pg.sprite.spritecollide(car, self.all_boosters, True, pg.sprite.collide_mask)  # maybe in this case it can be set to true
         if pick_ups:
+            print("Booster picked up!")
             for boost in pick_ups:
-                pass  # activate booster!
+                boost.activate(car, self.stopwatch)

map.py

@@ -15,6 +15,7 @@ def __init__(self, screen, clock, position: Vector2D):
         self.difference = 0
 
     def display_timer(self, ticks):
+        print("ticks: ", ticks, ", diff: ", self.difference, "t-d: ", ticks - self.difference)
         millis = (ticks - self.difference) % 1000
         seconds = int((ticks - self.difference) / 1000 % 60)
         minutes = int((ticks - self.difference) / 60000 % 24)
@@ -30,4 +31,4 @@ def stop_timer(self):
         pass
 
     def decrease_timer(self, value: int):
-        self.difference = value
+        self.difference += value